[INFO] cloning repository https://github.com/GeoSpark/autel-odl [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/GeoSpark/autel-odl" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] bd0458136b6c3dbf4478a25a39612428628fc0e3 [INFO] checking GeoSpark/autel-odl against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl" "/workspace/builds/worker-6-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-6-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/GeoSpark/autel-odl [INFO] finished tweaking git repo https://github.com/GeoSpark/autel-odl [INFO] tweaked toml for git repo https://github.com/GeoSpark/autel-odl written to /workspace/builds/worker-6-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/GeoSpark/autel-odl 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] crate git repo https://github.com/GeoSpark/autel-odl already has a lockfile, it will not be regenerated [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-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-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] 0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2 [INFO] running `Command { std: "docker" "start" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", 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" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", 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" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.106 [INFO] [stderr] Compiling quote v1.0.45 [INFO] [stderr] Compiling serde_core v1.0.228 [INFO] [stderr] Compiling unicode-ident v1.0.24 [INFO] [stderr] Compiling crc32fast v1.5.0 [INFO] [stderr] Compiling autocfg v1.5.0 [INFO] [stderr] Checking adler2 v2.0.1 [INFO] [stderr] Compiling zmij v1.0.21 [INFO] [stderr] Checking memchr v2.8.0 [INFO] [stderr] Checking cfg-if v1.0.4 [INFO] [stderr] Checking simd-adler32 v0.3.9 [INFO] [stderr] Checking encoding-next-index-tradchinese v1.20180106.1 [INFO] [stderr] Checking encoding-next-types v0.2.0 [INFO] [stderr] Compiling serde v1.0.228 [INFO] [stderr] Compiling serde_json v1.0.149 [INFO] [stderr] Checking unicode-segmentation v1.13.2 [INFO] [stderr] Checking itoa v1.0.18 [INFO] [stderr] Checking encoding-next-index-japanese v1.20180106.0 [INFO] [stderr] Checking encoding-next-index-korean v1.20180106.0 [INFO] [stderr] Checking encoding-next-index-simpchinese v1.20180106.0 [INFO] [stderr] Checking encoding-next-index-singlebyte v1.20180106.0 [INFO] [stderr] Checking miniz_oxide v0.8.9 [INFO] [stderr] Checking iana-time-zone v0.1.65 [INFO] [stderr] Checking cp437 v0.1.1 [INFO] [stderr] Checking ryu v1.0.23 [INFO] [stderr] Checking convert_case v0.11.0 [INFO] [stderr] Compiling num-traits v0.2.19 [INFO] [stderr] Checking encoding-next v0.3.0 [INFO] [stderr] Checking flate2 v1.1.9 [INFO] [stderr] Checking csv-core v0.1.13 [INFO] [stderr] Checking kaitai v0.11.0 (https://github.com/kaitai-io/kaitai_struct_rust_runtime.git?tag=v0.11.0#770aff09) [INFO] [stderr] Compiling syn v2.0.117 [INFO] [stderr] Checking chrono v0.4.44 [INFO] [stderr] Compiling serde_derive v1.0.228 [INFO] [stderr] Checking csv v1.4.0 [INFO] [stderr] Checking autel-odl v0.1.4 (/opt/rustwide/workdir) [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:55:39 [INFO] [stdout] | [INFO] [stdout] 55 | *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 55 - *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] 55 + *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] 55 + *self_rc.magic.borrow_mut() = as Into<_>>::into(_io.read_bytes(8 as usize)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:59:45 [INFO] [stdout] | [INFO] [stdout] 59 | *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 59 - *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 59 + *self_rc.log_version.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 59 + *self_rc.log_version.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:63:17 [INFO] [stdout] | [INFO] [stdout] 63 | let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 63 - let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 63 + let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 63 - let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 63 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:69:25 [INFO] [stdout] | [INFO] [stdout] 69 | ...t t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 69 - let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 69 + let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 69 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:342:49 [INFO] [stdout] | [INFO] [stdout] 342 | *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 342 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 342 + *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 342 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 342 + *self_rc.mission_time_ms.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:343:17 [INFO] [stdout] | [INFO] [stdout] 343 | let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 343 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 343 + let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 343 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 343 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:345:17 [INFO] [stdout] | [INFO] [stdout] 345 | let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 345 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 345 + let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 345 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 345 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:347:41 [INFO] [stdout] | [INFO] [stdout] 347 | *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 347 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 347 + *self_rc.rc_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 347 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 347 + *self_rc.rc_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:348:50 [INFO] [stdout] | [INFO] [stdout] 348 | *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 348 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 348 + *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 348 + *self_rc.offline_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:349:44 [INFO] [stdout] | [INFO] [stdout] 349 | *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 349 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 349 + *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 349 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 349 + *self_rc.rc_buttons.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:350:52 [INFO] [stdout] | [INFO] [stdout] 350 | *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 350 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 350 + *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 350 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 350 + *self_rc.controller_heading.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:351:17 [INFO] [stdout] | [INFO] [stdout] 351 | let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 351 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 351 + let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 351 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 351 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:353:40 [INFO] [stdout] | [INFO] [stdout] 353 | *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 353 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 353 + *self_rc.param1.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 353 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 353 + *self_rc.param1.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:354:40 [INFO] [stdout] | [INFO] [stdout] 354 | *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 354 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 354 + *self_rc.param2.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 354 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 354 + *self_rc.param2.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:480:45 [INFO] [stdout] | [INFO] [stdout] 480 | *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 480 - *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 480 + *self_rc.camera_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 480 - *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 480 + *self_rc.camera_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:481:43 [INFO] [stdout] | [INFO] [stdout] 481 | *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 481 - *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 481 + *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 481 - *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 481 + *self_rc.gnss_rssi.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:482:49 [INFO] [stdout] | [INFO] [stdout] 482 | *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 482 + *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 482 - *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 482 + *self_rc.controller_rssi.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:483:44 [INFO] [stdout] | [INFO] [stdout] 483 | *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 483 - *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 483 + *self_rc.stick_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 483 - *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 483 + *self_rc.stick_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:484:17 [INFO] [stdout] | [INFO] [stdout] 484 | ... t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 484 - let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 484 + let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 484 - let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 484 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:486:48 [INFO] [stdout] | [INFO] [stdout] 486 | *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 486 - *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 486 + *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 486 - *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 486 + *self_rc.distance_flown.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:487:53 [INFO] [stdout] | [INFO] [stdout] 487 | *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 487 - *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 487 + *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 - *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 487 + *self_rc.drone_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:488:57 [INFO] [stdout] | [INFO] [stdout] 488 | *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 488 - *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 488 + *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 488 - *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 488 + *self_rc.drone_ext_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:489:54 [INFO] [stdout] | [INFO] [stdout] 489 | *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 489 - *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 489 + *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 489 - *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 489 + *self_rc.gimbal_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:490:48 [INFO] [stdout] | [INFO] [stdout] 490 | *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 490 - *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 490 + *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 490 - *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 490 + *self_rc.time_remaining.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:491:43 [INFO] [stdout] | [INFO] [stdout] 491 | *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 491 - *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 491 + *self_rc.back_time.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 491 - *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 491 + *self_rc.back_time.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:492:49 [INFO] [stdout] | [INFO] [stdout] 492 | *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 492 + *self_rc.satellite_count.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 492 - *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 492 + *self_rc.satellite_count.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:493:17 [INFO] [stdout] | [INFO] [stdout] 493 | ...t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 493 - let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 493 + let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 - let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 493 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:495:17 [INFO] [stdout] | [INFO] [stdout] 495 | ... t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 495 - let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 495 + let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 495 - let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 495 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:642:46 [INFO] [stdout] | [INFO] [stdout] 642 | *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 642 - *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 642 + *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 642 - *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 642 + *self_rc.left_stick_x.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:643:46 [INFO] [stdout] | [INFO] [stdout] 643 | *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 643 - *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 643 + *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 643 - *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 643 + *self_rc.left_stick_y.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:644:47 [INFO] [stdout] | [INFO] [stdout] 644 | *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 644 - *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 644 + *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 644 - *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 644 + *self_rc.right_stick_x.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:645:47 [INFO] [stdout] | [INFO] [stdout] 645 | *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 645 - *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 645 + *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 645 - *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 645 + *self_rc.right_stick_y.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:718:48 [INFO] [stdout] | [INFO] [stdout] 718 | *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 718 - *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 718 + *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 718 - *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 718 + *self_rc.drone_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:719:49 [INFO] [stdout] | [INFO] [stdout] 719 | *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 719 - *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 719 + *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 719 - *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 719 + *self_rc.drone_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:720:48 [INFO] [stdout] | [INFO] [stdout] 720 | *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 720 - *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 720 + *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 720 - *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 720 + *self_rc.drone_altitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:721:47 [INFO] [stdout] | [INFO] [stdout] 721 | *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 721 - *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 721 + *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 721 - *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 721 + *self_rc.drone_x_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:722:47 [INFO] [stdout] | [INFO] [stdout] 722 | *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 722 - *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 722 + *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 722 - *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 722 + *self_rc.drone_y_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:55:39 [INFO] [stdout] | [INFO] [stdout] 55 | *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 55 - *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] 55 + *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into(); [INFO] [stdout] 55 + *self_rc.magic.borrow_mut() = as Into<_>>::into(_io.read_bytes(8 as usize)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:723:47 [INFO] [stdout] | [INFO] [stdout] 723 | *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 723 - *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 723 + *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 723 - *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 723 + *self_rc.drone_z_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:59:45 [INFO] [stdout] | [INFO] [stdout] 59 | *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 59 - *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 59 + *self_rc.log_version.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 59 + *self_rc.log_version.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:724:46 [INFO] [stdout] | [INFO] [stdout] 724 | *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 724 - *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 724 + *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 724 - *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 724 + *self_rc.gimbal_pitch.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:725:45 [INFO] [stdout] | [INFO] [stdout] 725 | *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 725 - *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 725 + *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 725 - *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 725 + *self_rc.gimbal_roll.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:726:44 [INFO] [stdout] | [INFO] [stdout] 726 | *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 726 - *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 726 + *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 726 - *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 726 + *self_rc.gimbal_yaw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:727:45 [INFO] [stdout] | [INFO] [stdout] 727 | *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 727 - *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 727 + *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 727 - *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 727 + *self_rc.drone_pitch.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:728:44 [INFO] [stdout] | [INFO] [stdout] 728 | *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 728 - *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 728 + *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 728 - *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 728 + *self_rc.drone_roll.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:729:43 [INFO] [stdout] | [INFO] [stdout] 729 | *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 729 - *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 729 + *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 729 - *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 729 + *self_rc.drone_yaw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:879:49 [INFO] [stdout] | [INFO] [stdout] 879 | *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 879 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 879 + *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 879 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 879 + *self_rc.mission_time_ms.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:63:17 [INFO] [stdout] | [INFO] [stdout] 63 | let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 63 - let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 63 + let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 63 - let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 63 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:880:17 [INFO] [stdout] | [INFO] [stdout] 880 | let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 880 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 880 + let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 880 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 880 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:882:17 [INFO] [stdout] | [INFO] [stdout] 882 | let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 882 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 882 + let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 882 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 882 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:69:25 [INFO] [stdout] | [INFO] [stdout] 69 | ...t t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 69 - let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 69 + let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 69 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:884:41 [INFO] [stdout] | [INFO] [stdout] 884 | *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 884 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 884 + *self_rc.rc_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 884 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 884 + *self_rc.rc_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:885:50 [INFO] [stdout] | [INFO] [stdout] 885 | *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 885 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 885 + *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 885 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 885 + *self_rc.offline_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:886:44 [INFO] [stdout] | [INFO] [stdout] 886 | *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 886 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 886 + *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 886 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 886 + *self_rc.rc_buttons.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:342:49 [INFO] [stdout] | [INFO] [stdout] 342 | *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 342 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 342 + *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 342 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 342 + *self_rc.mission_time_ms.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:887:52 [INFO] [stdout] | [INFO] [stdout] 887 | *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 887 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 887 + *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 887 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 887 + *self_rc.controller_heading.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:343:17 [INFO] [stdout] | [INFO] [stdout] 343 | let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 343 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 343 + let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 343 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 343 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:888:17 [INFO] [stdout] | [INFO] [stdout] 888 | let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 888 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 888 + let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 888 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 888 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:345:17 [INFO] [stdout] | [INFO] [stdout] 345 | let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 345 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 345 + let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 345 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 345 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:890:17 [INFO] [stdout] | [INFO] [stdout] 890 | ... = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 890 - let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 890 + let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 890 - let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 890 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:892:40 [INFO] [stdout] | [INFO] [stdout] 892 | *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 892 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 892 + *self_rc.param1.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 892 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 892 + *self_rc.param1.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:347:41 [INFO] [stdout] | [INFO] [stdout] 347 | *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 347 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 347 + *self_rc.rc_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 347 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 347 + *self_rc.rc_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:893:40 [INFO] [stdout] | [INFO] [stdout] 893 | *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 893 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 893 + *self_rc.param2.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 893 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 893 + *self_rc.param2.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:348:50 [INFO] [stdout] | [INFO] [stdout] 348 | *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 348 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 348 + *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 348 + *self_rc.offline_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:894:40 [INFO] [stdout] | [INFO] [stdout] 894 | *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 894 - *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 894 + *self_rc.param3.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 894 - *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 894 + *self_rc.param3.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:895:40 [INFO] [stdout] | [INFO] [stdout] 895 | *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 895 - *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 895 + *self_rc.param4.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 895 - *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 895 + *self_rc.param4.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:349:44 [INFO] [stdout] | [INFO] [stdout] 349 | *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 349 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 349 + *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 349 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 349 + *self_rc.rc_buttons.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:896:40 [INFO] [stdout] | [INFO] [stdout] 896 | *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 896 - *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 896 + *self_rc.param5.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 896 - *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 896 + *self_rc.param5.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:350:52 [INFO] [stdout] | [INFO] [stdout] 350 | *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 350 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 350 + *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 350 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 350 + *self_rc.controller_heading.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1055:45 [INFO] [stdout] | [INFO] [stdout] 1055 | *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1055 - *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1055 + *self_rc.header_size.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1055 - *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1055 + *self_rc.header_size.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1056:60 [INFO] [stdout] | [INFO] [stdout] 1056 | *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1056 - *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1056 + *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1056 - *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1056 + *self_rc.drone_serial.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(18 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1057:62 [INFO] [stdout] | [INFO] [stdout] 1057 | *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1057 - *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1057 + *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1057 - *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1057 + *self_rc.battery_serial.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(32 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1058:56 [INFO] [stdout] | [INFO] [stdout] 1058 | *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1058 - *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1058 + *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1058 - *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1058 + *self_rc.location.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1059:44 [INFO] [stdout] | [INFO] [stdout] 1059 | *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1059 - *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1059 + *self_rc.drone_type.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1059 - *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1059 + *self_rc.drone_type.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1060:42 [INFO] [stdout] | [INFO] [stdout] 1060 | *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1060 - *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1060 + *self_rc.distance.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1060 - *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1060 + *self_rc.distance.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1061:51 [INFO] [stdout] | [INFO] [stdout] 1061 | *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1061 - *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1061 + *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1061 - *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1061 + *self_rc.flight_duration_s.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1062:46 [INFO] [stdout] | [INFO] [stdout] 1062 | *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1062 - *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1062 + *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1062 - *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1062 + *self_rc.max_altitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1063:48 [INFO] [stdout] | [INFO] [stdout] 1063 | *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1063 - *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1063 + *self_rc.video_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1063 - *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1063 + *self_rc.video_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:351:17 [INFO] [stdout] | [INFO] [stdout] 351 | let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 351 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 351 + let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 351 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 351 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1064:47 [INFO] [stdout] | [INFO] [stdout] 1064 | *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1064 - *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1064 + *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1064 - *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1064 + *self_rc.start_time_ms.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:353:40 [INFO] [stdout] | [INFO] [stdout] 353 | *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 353 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 353 + *self_rc.param1.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 353 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 353 + *self_rc.param1.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1065:42 [INFO] [stdout] | [INFO] [stdout] 1065 | *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1065 - *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1065 + *self_rc.timezone.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1065 - *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1065 + *self_rc.timezone.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:354:40 [INFO] [stdout] | [INFO] [stdout] 354 | *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 354 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 354 + *self_rc.param2.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 354 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 354 + *self_rc.param2.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1066:48 [INFO] [stdout] | [INFO] [stdout] 1066 | *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1066 - *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1066 + *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1066 - *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1066 + *self_rc.start_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:480:45 [INFO] [stdout] | [INFO] [stdout] 480 | *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 480 - *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 480 + *self_rc.camera_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 480 - *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 480 + *self_rc.camera_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:481:43 [INFO] [stdout] | [INFO] [stdout] 481 | *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 481 - *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 481 + *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 481 - *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 481 + *self_rc.gnss_rssi.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1067:49 [INFO] [stdout] | [INFO] [stdout] 1067 | *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1067 - *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1067 + *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1067 - *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1067 + *self_rc.start_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:482:49 [INFO] [stdout] | [INFO] [stdout] 482 | *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 482 + *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 482 - *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 482 + *self_rc.controller_rssi.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:483:44 [INFO] [stdout] | [INFO] [stdout] 483 | *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 483 - *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 483 + *self_rc.stick_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 483 - *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 483 + *self_rc.stick_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1068:45 [INFO] [stdout] | [INFO] [stdout] 1068 | *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1068 - *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1068 + *self_rc.image_count.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1068 - *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1068 + *self_rc.image_count.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:484:17 [INFO] [stdout] | [INFO] [stdout] 484 | ... t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 484 - let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 484 + let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 484 - let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 484 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:486:48 [INFO] [stdout] | [INFO] [stdout] 486 | *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 486 - *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 486 + *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 486 - *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 486 + *self_rc.distance_flown.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1069:45 [INFO] [stdout] | [INFO] [stdout] 1069 | *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1069 - *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1069 + *self_rc.video_count.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1069 - *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1069 + *self_rc.video_count.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:487:53 [INFO] [stdout] | [INFO] [stdout] 487 | *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 487 - *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 487 + *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 - *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 487 + *self_rc.drone_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1070:49 [INFO] [stdout] | [INFO] [stdout] 1070 | *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1070 - *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1070 + *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1070 - *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1070 + *self_rc.firmware_length.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:488:57 [INFO] [stdout] | [INFO] [stdout] 488 | *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 488 - *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 488 + *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 488 - *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 488 + *self_rc.drone_ext_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:489:54 [INFO] [stdout] | [INFO] [stdout] 489 | *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 489 - *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 489 + *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 489 - *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 489 + *self_rc.gimbal_warning_flags.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:490:48 [INFO] [stdout] | [INFO] [stdout] 490 | *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 490 - *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 490 + *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 490 - *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 490 + *self_rc.time_remaining.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1071:61 [INFO] [stdout] | [INFO] [stdout] 1071 | *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1071 - *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1071 + *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1071 - *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1071 + *self_rc.firmware_info.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(*self_rc.firmware_length() as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:491:43 [INFO] [stdout] | [INFO] [stdout] 491 | *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 491 - *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 491 + *self_rc.back_time.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 491 - *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 491 + *self_rc.back_time.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1195:47 [INFO] [stdout] | [INFO] [stdout] 1195 | *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1195 + *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1195 - *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1195 + *self_rc.home_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:492:49 [INFO] [stdout] | [INFO] [stdout] 492 | *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 492 + *self_rc.satellite_count.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 492 - *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 492 + *self_rc.satellite_count.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:493:17 [INFO] [stdout] | [INFO] [stdout] 493 | ...t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 493 - let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 493 + let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 - let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 493 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1196:48 [INFO] [stdout] | [INFO] [stdout] 1196 | *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1196 - *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1196 + *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1196 - *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1196 + *self_rc.home_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1197:52 [INFO] [stdout] | [INFO] [stdout] 1197 | *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1197 - *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1197 + *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1197 - *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1197 + *self_rc.distance_to_home_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:495:17 [INFO] [stdout] | [INFO] [stdout] 495 | ... t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 495 - let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 495 + let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 495 - let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 495 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:1255:43 [INFO] [stdout] | [INFO] [stdout] 1255 | *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1255 - *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 1255 + *self_rc.timestamp.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1255 - *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 1255 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1256:46 [INFO] [stdout] | [INFO] [stdout] 1256 | *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1256 - *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1256 + *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1256 - *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1256 + *self_rc.front_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:642:46 [INFO] [stdout] | [INFO] [stdout] 642 | *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 642 - *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 642 + *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 642 - *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 642 + *self_rc.left_stick_x.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:643:46 [INFO] [stdout] | [INFO] [stdout] 643 | *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 643 - *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 643 + *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 643 - *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 643 + *self_rc.left_stick_y.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1257:45 [INFO] [stdout] | [INFO] [stdout] 1257 | *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1257 - *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1257 + *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1257 - *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1257 + *self_rc.rear_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:644:47 [INFO] [stdout] | [INFO] [stdout] 644 | *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 644 - *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 644 + *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 644 - *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 644 + *self_rc.right_stick_x.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:645:47 [INFO] [stdout] | [INFO] [stdout] 645 | *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 645 - *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 645 + *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 645 - *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 645 + *self_rc.right_stick_y.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:718:48 [INFO] [stdout] | [INFO] [stdout] 718 | *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 718 - *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 718 + *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 718 - *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 718 + *self_rc.drone_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:719:49 [INFO] [stdout] | [INFO] [stdout] 719 | *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 719 - *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 719 + *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 719 - *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 719 + *self_rc.drone_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:720:48 [INFO] [stdout] | [INFO] [stdout] 720 | *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 720 - *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 720 + *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 720 - *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 720 + *self_rc.drone_altitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:721:47 [INFO] [stdout] | [INFO] [stdout] 721 | *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 721 - *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 721 + *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 721 - *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 721 + *self_rc.drone_x_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:722:47 [INFO] [stdout] | [INFO] [stdout] 722 | *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 722 - *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 722 + *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 722 - *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 722 + *self_rc.drone_y_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:723:47 [INFO] [stdout] | [INFO] [stdout] 723 | *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 723 - *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 723 + *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 723 - *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 723 + *self_rc.drone_z_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:724:46 [INFO] [stdout] | [INFO] [stdout] 724 | *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 724 - *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 724 + *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 724 - *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 724 + *self_rc.gimbal_pitch.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:725:45 [INFO] [stdout] | [INFO] [stdout] 725 | *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 725 - *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 725 + *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 725 - *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 725 + *self_rc.gimbal_roll.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:726:44 [INFO] [stdout] | [INFO] [stdout] 726 | *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 726 - *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 726 + *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 726 - *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 726 + *self_rc.gimbal_yaw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:727:45 [INFO] [stdout] | [INFO] [stdout] 727 | *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 727 - *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 727 + *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 727 - *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 727 + *self_rc.drone_pitch.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1258:45 [INFO] [stdout] | [INFO] [stdout] 1258 | *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1258 - *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1258 + *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1258 - *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1258 + *self_rc.left_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:728:44 [INFO] [stdout] | [INFO] [stdout] 728 | *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 728 - *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 728 + *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 728 - *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 728 + *self_rc.drone_roll.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:729:43 [INFO] [stdout] | [INFO] [stdout] 729 | *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 729 - *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 729 + *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 729 - *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 729 + *self_rc.drone_yaw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:879:49 [INFO] [stdout] | [INFO] [stdout] 879 | *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 879 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 879 + *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 879 - *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 879 + *self_rc.mission_time_ms.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:880:17 [INFO] [stdout] | [INFO] [stdout] 880 | let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 880 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 880 + let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 880 - let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 880 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:882:17 [INFO] [stdout] | [INFO] [stdout] 882 | let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 882 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 882 + let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 882 - let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 882 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1259:46 [INFO] [stdout] | [INFO] [stdout] 1259 | *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1259 - *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1259 + *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1259 - *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1259 + *self_rc.right_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1260:44 [INFO] [stdout] | [INFO] [stdout] 1260 | *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1260 - *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1260 + *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1260 - *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1260 + *self_rc.top_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1261:47 [INFO] [stdout] | [INFO] [stdout] 1261 | *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1261 - *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1261 + *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1261 - *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1261 + *self_rc.bottom_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1341:57 [INFO] [stdout] | [INFO] [stdout] 1341 | *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1341 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1341 + *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1341 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1341 + *self_rc.file_name.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1342:43 [INFO] [stdout] | [INFO] [stdout] 1342 | *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1342 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1342 + *self_rc.timestamp.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1342 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1342 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1343:42 [INFO] [stdout] | [INFO] [stdout] 1343 | *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1343 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1343 + *self_rc.latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1343 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1343 + *self_rc.latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1344:43 [INFO] [stdout] | [INFO] [stdout] 1344 | *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1344 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1344 + *self_rc.longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1344 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1344 + *self_rc.longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1415:49 [INFO] [stdout] | [INFO] [stdout] 1415 | *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1415 - *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1415 + *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1415 - *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1415 + *self_rc.designed_volume.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1416:54 [INFO] [stdout] | [INFO] [stdout] 1416 | *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1416 - *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1416 + *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1416 - *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1416 + *self_rc.maximum_capacity_mah.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1417:54 [INFO] [stdout] | [INFO] [stdout] 1417 | *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1417 - *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1417 + *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1417 - *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1417 + *self_rc.current_capacity_mah.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:884:41 [INFO] [stdout] | [INFO] [stdout] 884 | *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 884 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 884 + *self_rc.rc_mode.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 884 - *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 884 + *self_rc.rc_mode.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:885:50 [INFO] [stdout] | [INFO] [stdout] 885 | *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 885 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 885 + *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 885 - *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 885 + *self_rc.offline_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1418:44 [INFO] [stdout] | [INFO] [stdout] 1418 | *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1418 - *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1418 + *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1418 - *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1418 + *self_rc.voltage_mv.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:886:44 [INFO] [stdout] | [INFO] [stdout] 886 | *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 886 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 886 + *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 886 - *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 886 + *self_rc.rc_buttons.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:887:52 [INFO] [stdout] | [INFO] [stdout] 887 | *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 887 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 887 + *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 887 - *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 887 + *self_rc.controller_heading.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1419:46 [INFO] [stdout] | [INFO] [stdout] 1419 | *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1419 - *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1419 + *self_rc.current_draw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1419 - *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1419 + *self_rc.current_draw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:888:17 [INFO] [stdout] | [INFO] [stdout] 888 | let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 888 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 888 + let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 888 - let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into(); [INFO] [stdout] 888 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc` [INFO] [stdout] --> src/autel_drone_log.rs:890:17 [INFO] [stdout] | [INFO] [stdout] 890 | ... = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 890 - let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 890 + let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 890 - let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into(); [INFO] [stdout] 890 + let t = as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:892:40 [INFO] [stdout] | [INFO] [stdout] 892 | *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 892 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 892 + *self_rc.param1.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 892 - *self_rc.param1.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 892 + *self_rc.param1.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1420:53 [INFO] [stdout] | [INFO] [stdout] 1420 | *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1420 - *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1420 + *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1420 - *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1420 + *self_rc.remaining_charge_pc.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:893:40 [INFO] [stdout] | [INFO] [stdout] 893 | *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 893 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 893 + *self_rc.param2.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 893 - *self_rc.param2.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 893 + *self_rc.param2.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:894:40 [INFO] [stdout] | [INFO] [stdout] 894 | *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 894 - *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 894 + *self_rc.param3.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 894 - *self_rc.param3.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 894 + *self_rc.param3.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:895:40 [INFO] [stdout] | [INFO] [stdout] 895 | *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 895 - *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 895 + *self_rc.param4.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 895 - *self_rc.param4.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 895 + *self_rc.param4.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1421:59 [INFO] [stdout] | [INFO] [stdout] 1421 | *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1421 - *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1421 + *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1421 - *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1421 + *self_rc.battery_temperature_deg_c.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:896:40 [INFO] [stdout] | [INFO] [stdout] 896 | *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 896 - *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 896 + *self_rc.param5.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 896 - *self_rc.param5.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 896 + *self_rc.param5.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1423:57 [INFO] [stdout] | [INFO] [stdout] 1423 | *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1423 - *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1423 + *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1423 - *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1423 + *self_rc.battery_discharge_count.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1424:44 [INFO] [stdout] | [INFO] [stdout] 1424 | *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1424 - *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1424 + *self_rc.cell_count.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1424 - *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1424 + *self_rc.cell_count.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1428:52 [INFO] [stdout] | [INFO] [stdout] 1428 | self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1428 - self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] 1428 + self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1428 - self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] 1428 + self_rc.cell_voltage.borrow_mut().push(>::into(_io.read_f4le()?)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1055:45 [INFO] [stdout] | [INFO] [stdout] 1055 | *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1055 - *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1055 + *self_rc.header_size.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1055 - *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1055 + *self_rc.header_size.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1595:45 [INFO] [stdout] | [INFO] [stdout] 1595 | *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1595 - *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1595 + *self_rc.record_type.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1595 - *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1595 + *self_rc.record_type.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1684:52 [INFO] [stdout] | [INFO] [stdout] 1684 | *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1684 - *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1684 + *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1684 - *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1684 + *self_rc.oa_warning_enabled.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1056:60 [INFO] [stdout] | [INFO] [stdout] 1056 | *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1056 - *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1056 + *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1056 - *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1056 + *self_rc.drone_serial.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(18 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1685:56 [INFO] [stdout] | [INFO] [stdout] 1685 | *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1685 - *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1685 + *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1685 - *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1685 + *self_rc.oa_ext_warning_enabled.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1057:62 [INFO] [stdout] | [INFO] [stdout] 1057 | *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1057 - *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1057 + *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1057 - *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1057 + *self_rc.battery_serial.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(32 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1686:47 [INFO] [stdout] | [INFO] [stdout] 1686 | *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1686 - *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1686 + *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1686 - *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1686 + *self_rc.oa_error_code.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1058:56 [INFO] [stdout] | [INFO] [stdout] 1058 | *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1058 - *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1058 + *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1058 - *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1058 + *self_rc.location.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1687:48 [INFO] [stdout] | [INFO] [stdout] 1687 | *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1687 - *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1687 + *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1687 - *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1687 + *self_rc.max_altitude_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1059:44 [INFO] [stdout] | [INFO] [stdout] 1059 | *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1059 - *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1059 + *self_rc.drone_type.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1059 - *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1059 + *self_rc.drone_type.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1688:59 [INFO] [stdout] | [INFO] [stdout] 1688 | *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1688 - *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1688 + *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1688 - *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1688 + *self_rc.return_to_home_altitude_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1689:55 [INFO] [stdout] | [INFO] [stdout] 1689 | *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1689 - *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1689 + *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1689 - *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1689 + *self_rc.beginner_mode_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1060:42 [INFO] [stdout] | [INFO] [stdout] 1060 | *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1060 - *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1060 + *self_rc.distance.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1060 - *self_rc.distance.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1060 + *self_rc.distance.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1061:51 [INFO] [stdout] | [INFO] [stdout] 1061 | *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1061 - *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1061 + *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1061 - *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1061 + *self_rc.flight_duration_s.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1062:46 [INFO] [stdout] | [INFO] [stdout] 1062 | *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1062 - *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1062 + *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1062 - *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1062 + *self_rc.max_altitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1063:48 [INFO] [stdout] | [INFO] [stdout] 1063 | *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1063 - *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1063 + *self_rc.video_duration.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1063 - *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1063 + *self_rc.video_duration.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1690:63 [INFO] [stdout] | [INFO] [stdout] 1690 | *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1690 - *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1690 + *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1690 - *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1690 + *self_rc.low_battery_threshold_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1064:47 [INFO] [stdout] | [INFO] [stdout] 1064 | *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1064 - *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1064 + *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1064 - *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1064 + *self_rc.start_time_ms.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1691:68 [INFO] [stdout] | [INFO] [stdout] 1691 | *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1691 - *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1691 + *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1691 - *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1691 + *self_rc.critical_battery_threshold_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1692:55 [INFO] [stdout] | [INFO] [stdout] 1692 | *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1692 - *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1692 + *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1692 - *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1692 + *self_rc.max_flight_distance_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1693:54 [INFO] [stdout] | [INFO] [stdout] 1693 | *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1693 - *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1693 + *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1693 - *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1693 + *self_rc.max_horizontal_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1065:42 [INFO] [stdout] | [INFO] [stdout] 1065 | *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1065 - *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1065 + *self_rc.timezone.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1065 - *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1065 + *self_rc.timezone.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1694:44 [INFO] [stdout] | [INFO] [stdout] 1694 | *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1694 - *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1694 + *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1694 - *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1694 + *self_rc.oa_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1695:47 [INFO] [stdout] | [INFO] [stdout] 1695 | *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1695 - *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1695 + *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1695 - *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1695 + *self_rc.radar_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1696:43 [INFO] [stdout] | [INFO] [stdout] 1696 | *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1696 - *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1696 + *self_rc.max_error.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1696 - *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1696 + *self_rc.max_error.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1066:48 [INFO] [stdout] | [INFO] [stdout] 1066 | *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1066 - *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1066 + *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1066 - *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1066 + *self_rc.start_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1067:49 [INFO] [stdout] | [INFO] [stdout] 1067 | *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1067 - *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1067 + *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1067 - *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1067 + *self_rc.start_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1806:57 [INFO] [stdout] | [INFO] [stdout] 1806 | *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1806 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1806 + *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1806 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1806 + *self_rc.file_name.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1068:45 [INFO] [stdout] | [INFO] [stdout] 1068 | *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1068 - *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1068 + *self_rc.image_count.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1068 - *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1068 + *self_rc.image_count.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1807:43 [INFO] [stdout] | [INFO] [stdout] 1807 | *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1807 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1807 + *self_rc.timestamp.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1807 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1807 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1069:45 [INFO] [stdout] | [INFO] [stdout] 1069 | *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1069 - *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1069 + *self_rc.video_count.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1069 - *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1069 + *self_rc.video_count.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/autel_drone_log.rs:1070:49 [INFO] [stdout] | [INFO] [stdout] 1070 | *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1070 - *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1070 + *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1070 - *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into(); [INFO] [stdout] 1070 + *self_rc.firmware_length.borrow_mut() = >::into(_io.read_u2le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1808:42 [INFO] [stdout] | [INFO] [stdout] 1808 | *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1808 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1808 + *self_rc.latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1808 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1808 + *self_rc.latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1809:43 [INFO] [stdout] | [INFO] [stdout] 1809 | *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1809 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1809 + *self_rc.longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1809 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1809 + *self_rc.longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1810:44 [INFO] [stdout] | [INFO] [stdout] 1810 | *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1810 - *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1810 + *self_rc.duration_s.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1810 - *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1810 + *self_rc.duration_s.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1071:61 [INFO] [stdout] | [INFO] [stdout] 1071 | *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1071 - *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1071 + *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1071 - *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1071 + *self_rc.firmware_info.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(*self_rc.firmware_length() as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1195:47 [INFO] [stdout] | [INFO] [stdout] 1195 | *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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 - *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1195 + *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1195 - *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1195 + *self_rc.home_latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1196:48 [INFO] [stdout] | [INFO] [stdout] 1196 | *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1196 - *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1196 + *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1196 - *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1196 + *self_rc.home_longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1197:52 [INFO] [stdout] | [INFO] [stdout] 1197 | *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1197 - *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1197 + *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1197 - *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1197 + *self_rc.distance_to_home_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f64` [INFO] [stdout] --> src/autel_drone_log.rs:1255:43 [INFO] [stdout] | [INFO] [stdout] 1255 | *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1255 - *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 1255 + *self_rc.timestamp.borrow_mut() = _io.read_f8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1255 - *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into(); [INFO] [stdout] 1255 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_f8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1256:46 [INFO] [stdout] | [INFO] [stdout] 1256 | *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1256 - *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1256 + *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1256 - *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1256 + *self_rc.front_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1257:45 [INFO] [stdout] | [INFO] [stdout] 1257 | *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1257 - *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1257 + *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1257 - *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1257 + *self_rc.rear_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1258:45 [INFO] [stdout] | [INFO] [stdout] 1258 | *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1258 - *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1258 + *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1258 - *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1258 + *self_rc.left_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1259:46 [INFO] [stdout] | [INFO] [stdout] 1259 | *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1259 - *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1259 + *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1259 - *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1259 + *self_rc.right_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1260:44 [INFO] [stdout] | [INFO] [stdout] 1260 | *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1260 - *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1260 + *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1260 - *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1260 + *self_rc.top_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1261:47 [INFO] [stdout] | [INFO] [stdout] 1261 | *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1261 - *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1261 + *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1261 - *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1261 + *self_rc.bottom_sensor.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1341:57 [INFO] [stdout] | [INFO] [stdout] 1341 | *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1341 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1341 + *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1341 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1341 + *self_rc.file_name.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1342:43 [INFO] [stdout] | [INFO] [stdout] 1342 | *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1342 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1342 + *self_rc.timestamp.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1342 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1342 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1343:42 [INFO] [stdout] | [INFO] [stdout] 1343 | *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1343 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1343 + *self_rc.latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1343 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1343 + *self_rc.latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1344:43 [INFO] [stdout] | [INFO] [stdout] 1344 | *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1344 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1344 + *self_rc.longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1344 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1344 + *self_rc.longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1415:49 [INFO] [stdout] | [INFO] [stdout] 1415 | *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1415 - *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1415 + *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1415 - *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1415 + *self_rc.designed_volume.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1416:54 [INFO] [stdout] | [INFO] [stdout] 1416 | *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1416 - *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1416 + *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1416 - *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1416 + *self_rc.maximum_capacity_mah.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1417:54 [INFO] [stdout] | [INFO] [stdout] 1417 | *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1417 - *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1417 + *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1417 - *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1417 + *self_rc.current_capacity_mah.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1418:44 [INFO] [stdout] | [INFO] [stdout] 1418 | *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1418 - *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1418 + *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1418 - *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1418 + *self_rc.voltage_mv.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1419:46 [INFO] [stdout] | [INFO] [stdout] 1419 | *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1419 - *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1419 + *self_rc.current_draw.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1419 - *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1419 + *self_rc.current_draw.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1420:53 [INFO] [stdout] | [INFO] [stdout] 1420 | *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1420 - *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1420 + *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1420 - *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1420 + *self_rc.remaining_charge_pc.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1421:59 [INFO] [stdout] | [INFO] [stdout] 1421 | *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1421 - *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1421 + *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1421 - *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1421 + *self_rc.battery_temperature_deg_c.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1423:57 [INFO] [stdout] | [INFO] [stdout] 1423 | *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1423 - *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1423 + *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1423 - *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1423 + *self_rc.battery_discharge_count.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1424:44 [INFO] [stdout] | [INFO] [stdout] 1424 | *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1424 - *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1424 + *self_rc.cell_count.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1424 - *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1424 + *self_rc.cell_count.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1428:52 [INFO] [stdout] | [INFO] [stdout] 1428 | self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1428 - self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] 1428 + self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1428 - self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into()); [INFO] [stdout] 1428 + self_rc.cell_voltage.borrow_mut().push(>::into(_io.read_f4le()?)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1595:45 [INFO] [stdout] | [INFO] [stdout] 1595 | *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1595 - *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1595 + *self_rc.record_type.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1595 - *self_rc.record_type.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1595 + *self_rc.record_type.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1684:52 [INFO] [stdout] | [INFO] [stdout] 1684 | *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1684 - *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1684 + *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1684 - *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1684 + *self_rc.oa_warning_enabled.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1685:56 [INFO] [stdout] | [INFO] [stdout] 1685 | *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1685 - *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1685 + *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1685 - *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1685 + *self_rc.oa_ext_warning_enabled.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1686:47 [INFO] [stdout] | [INFO] [stdout] 1686 | *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1686 - *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1686 + *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1686 - *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1686 + *self_rc.oa_error_code.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1687:48 [INFO] [stdout] | [INFO] [stdout] 1687 | *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1687 - *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1687 + *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1687 - *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1687 + *self_rc.max_altitude_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1688:59 [INFO] [stdout] | [INFO] [stdout] 1688 | *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1688 - *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1688 + *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1688 - *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1688 + *self_rc.return_to_home_altitude_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1689:55 [INFO] [stdout] | [INFO] [stdout] 1689 | *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1689 - *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1689 + *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1689 - *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1689 + *self_rc.beginner_mode_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1690:63 [INFO] [stdout] | [INFO] [stdout] 1690 | *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1690 - *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1690 + *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1690 - *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1690 + *self_rc.low_battery_threshold_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1691:68 [INFO] [stdout] | [INFO] [stdout] 1691 | *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1691 - *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1691 + *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1691 - *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1691 + *self_rc.critical_battery_threshold_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1692:55 [INFO] [stdout] | [INFO] [stdout] 1692 | *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1692 - *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1692 + *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1692 - *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1692 + *self_rc.max_flight_distance_m.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1693:54 [INFO] [stdout] | [INFO] [stdout] 1693 | *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1693 - *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1693 + *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1693 - *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1693 + *self_rc.max_horizontal_speed.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1694:44 [INFO] [stdout] | [INFO] [stdout] 1694 | *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1694 - *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1694 + *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1694 - *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1694 + *self_rc.oa_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/autel_drone_log.rs:1695:47 [INFO] [stdout] | [INFO] [stdout] 1695 | *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1695 - *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1695 + *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1695 - *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into(); [INFO] [stdout] 1695 + *self_rc.radar_enabled.borrow_mut() = >::into(_io.read_u1()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1696:43 [INFO] [stdout] | [INFO] [stdout] 1696 | *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1696 - *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1696 + *self_rc.max_error.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1696 - *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1696 + *self_rc.max_error.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `Vec` [INFO] [stdout] --> src/autel_drone_log.rs:1806:57 [INFO] [stdout] | [INFO] [stdout] 1806 | *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1806 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1806 + *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1806 - *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?; [INFO] [stdout] 1806 + *self_rc.file_name.borrow_mut() = bytes_to_str(& as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u64` [INFO] [stdout] --> src/autel_drone_log.rs:1807:43 [INFO] [stdout] | [INFO] [stdout] 1807 | *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1807 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1807 + *self_rc.timestamp.borrow_mut() = _io.read_u8le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1807 - *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into(); [INFO] [stdout] 1807 + *self_rc.timestamp.borrow_mut() = >::into(_io.read_u8le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1808:42 [INFO] [stdout] | [INFO] [stdout] 1808 | *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1808 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1808 + *self_rc.latitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1808 - *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1808 + *self_rc.latitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `f32` [INFO] [stdout] --> src/autel_drone_log.rs:1809:43 [INFO] [stdout] | [INFO] [stdout] 1809 | *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1809 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1809 + *self_rc.longitude.borrow_mut() = _io.read_f4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1809 - *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into(); [INFO] [stdout] 1809 + *self_rc.longitude.borrow_mut() = >::into(_io.read_f4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u32` [INFO] [stdout] --> src/autel_drone_log.rs:1810:44 [INFO] [stdout] | [INFO] [stdout] 1810 | *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into 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] 1810 - *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1810 + *self_rc.duration_s.borrow_mut() = _io.read_u4le()?; [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 1810 - *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into(); [INFO] [stdout] 1810 + *self_rc.duration_s.borrow_mut() = >::into(_io.read_u4le()?); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `autel-odl` (bin "autel-odl") due to 118 previous errors [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] error: could not compile `autel-odl` (bin "autel-odl" test) due to 118 previous errors [INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }` [INFO] [stdout] 0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2