[INFO] fetching crate bevy_reflect_bms_bindings 0.23.0...
[INFO] checking bevy_reflect_bms_bindings-0.23.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate bevy_reflect_bms_bindings 0.23.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] finished tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] tweaked toml for crates.io crate bevy_reflect_bms_bindings 0.23.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate bevy_reflect_bms_bindings 0.23.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate bevy_reflect_bms_bindings 0.23.0 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" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:112:12
[INFO] [stderr]     |
[INFO] [stderr] 112 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 117 | repository = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |              -----------------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bevy_reflect_bms_bindings` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6
[INFO] running `Command { std: "docker" "start" "529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6", 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" "529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6", 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" "529a1dc02720db493ae0d465310c656b68d4ee6bae269a8bc819b2c29654c7c6" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:112:12
[INFO] [stderr]     |
[INFO] [stderr] 112 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 117 | repository = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |              -----------------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bevy_reflect_bms_bindings` (manifest) generated 1 warning
[INFO] [stderr]    Compiling crossbeam-utils v0.8.23
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]    Compiling libc v0.2.190
[INFO] [stderr]     Checking event-listener v5.4.2
[INFO] [stderr]     Checking futures-lite v2.6.1
[INFO] [stderr]    Compiling toml_parser v1.1.5+spec-1.1.0
[INFO] [stderr]    Compiling toml_datetime v1.1.2+spec-1.1.0
[INFO] [stderr]    Compiling thiserror v2.0.21
[INFO] [stderr]     Checking spin v0.12.3
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking smallvec v1.16.3
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]     Checking rustc-hash v1.1.0
[INFO] [stderr]    Compiling nix v0.31.3
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking raw-window-handle v0.6.2
[INFO] [stderr]     Checking disqualified v1.1.0
[INFO] [stderr]     Checking erased-serde v0.4.10
[INFO] [stderr]     Checking glam v0.33.12
[INFO] [stderr]     Checking arrayvec v0.7.8
[INFO] [stderr]     Checking inventory v0.3.25
[INFO] [stderr]     Checking bevy_ptr v0.20.0
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking event-listener-strategy v0.5.4
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]    Compiling rustix v1.1.5
[INFO] [stderr]    Compiling find-msvc-tools v0.1.14
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]    Compiling cc v1.8.0
[INFO] [stderr]    Compiling toml_edit v0.25.17+spec-1.1.0
[INFO] [stderr]     Checking tracing-log v0.2.0
[INFO] [stderr]     Checking concurrent-queue v2.5.0
[INFO] [stderr]     Checking crossbeam-queue v0.3.14
[INFO] [stderr]     Checking indexmap v2.14.2
[INFO] [stderr]     Checking piper v0.2.5
[INFO] [stderr]     Checking const_panic v0.2.17
[INFO] [stderr]     Checking async-lock v3.4.2
[INFO] [stderr]     Checking unicode-ident v1.0.27
[INFO] [stderr]     Checking crossbeam-channel v0.5.17
[INFO] [stderr]     Checking async-channel v2.5.0
[INFO] [stderr]     Checking async-executor v1.14.0
[INFO] [stderr]     Checking blocking v1.7.0
[INFO] [stderr]     Checking async-broadcast v0.7.2
[INFO] [stderr]     Checking dot-writer v0.1.4
[INFO] [stderr]     Checking stackfuture v0.3.1
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]    Compiling variadics_please v2.0.0
[INFO] [stderr]     Checking async-fs v2.2.0
[INFO] [stderr]    Compiling blake3 v1.8.7
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]     Checking uuid v1.28.0
[INFO] [stderr]     Checking matchers v0.2.0
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]     Checking ctrlc v3.5.2
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling bytemuck_derive v1.12.1
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]    Compiling futures-macro v0.3.34
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]    Compiling bevy_macro_utils v0.20.0
[INFO] [stderr]     Checking polling v3.11.0
[INFO] [stderr]     Checking async-io v2.6.0
[INFO] [stderr]    Compiling bevy_ecs_macro_logic v0.20.0
[INFO] [stderr]    Compiling derive_more-impl v2.1.1
[INFO] [stderr]    Compiling assert_type_match v0.1.1
[INFO] [stderr]    Compiling bevy_reflect_derive v0.20.0
[INFO] [stderr]    Compiling bevy_ecs_macros v0.20.0
[INFO] [stderr]    Compiling bevy_derive v0.20.0
[INFO] [stderr]    Compiling profiling-procmacros v1.0.18
[INFO] [stderr]    Compiling bevy_asset_macros v0.20.0
[INFO] [stderr]    Compiling bevy_mod_scripting_derive v0.23.0
[INFO] [stderr]    Compiling variadics_please v1.1.0
[INFO] [stderr]     Checking profiling v1.0.18
[INFO] [stderr]     Checking bevy_platform v0.20.0
[INFO] [stderr]     Checking naga-types v30.0.1
[INFO] [stderr]     Checking smol_str v0.2.2
[INFO] [stderr]     Checking petgraph v0.8.3
[INFO] [stderr]     Checking ron v0.12.2
[INFO] [stderr]     Checking bevy_utils v0.20.0
[INFO] [stderr]     Checking wgpu-types v30.0.1
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking bevy_tasks v0.20.0
[INFO] [stderr]     Checking bevy_reflect v0.20.0
[INFO] [stderr]     Checking bevy_ecs v0.20.0
[INFO] [stderr]     Checking bevy_app v0.20.0
[INFO] [stderr]     Checking bevy_log v0.20.0
[INFO] [stderr]     Checking bevy_time v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_world v0.23.0
[INFO] [stderr]     Checking bevy_system_reflection v0.23.0
[INFO] [stderr]     Checking bevy_diagnostic v0.20.0
[INFO] [stderr]     Checking bevy_asset v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_display v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_asset v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_bindings_domain v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_script v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_bindings v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_core v0.23.0
[INFO] [stderr]     Checking bevy_reflect_bms_bindings v0.23.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:42:44
[INFO] [stdout]    |
[INFO] [stdout] 42 |                           let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ____________________________________________^
[INFO] [stdout] 43 | |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 45 | |                             .into();
[INFO] [stdout]    | |___________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                         >>::eq(&_self, &other)
[INFO] [stdout] 45 -                             .into();
[INFO] [stdout] 44 +                         >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 ~                         let output: bool = <bool as Into<_>>::into(<::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout] 43 |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 ~                         >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:84:40
[INFO] [stdout]    |
[INFO] [stdout] 84 |                       let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 85 | |                         ::core::any::TypeId,
[INFO] [stdout] 86 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 87 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -                     >>::eq(&_self, &other)
[INFO] [stdout] 87 -                     .into();
[INFO] [stdout] 86 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 ~                     let output: bool = <bool as Into<_>>::into(<::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout] 85 |                         ::core::any::TypeId,
[INFO] [stdout] 86 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:110:44
[INFO] [stdout]     |
[INFO] [stdout] 110 |                           let output: bool = ::glam::Quat::abs_diff_eq(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 111 | |                                 _self.into_inner(),
[INFO] [stdout] 112 | |                                 rhs.into_inner(),
[INFO] [stdout] 113 | |                                 max_abs_diff,
[INFO] [stdout] 114 | |                             )
[INFO] [stdout] 115 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -                             )
[INFO] [stdout] 115 -                             .into();
[INFO] [stdout] 114 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::abs_diff_eq(
[INFO] [stdout] 111 |                                 _self.into_inner(),
[INFO] [stdout] 112 |                                 rhs.into_inner(),
[INFO] [stdout] 113 |                                 max_abs_diff,
[INFO] [stdout] 114 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:163:43
[INFO] [stdout]     |
[INFO] [stdout] 163 |                           let output: f32 = ::glam::Quat::angle_between(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 164 | |                                 _self.into_inner(),
[INFO] [stdout] 165 | |                                 rhs.into_inner(),
[INFO] [stdout] 166 | |                             )
[INFO] [stdout] 167 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -                             )
[INFO] [stdout] 167 -                             .into();
[INFO] [stdout] 166 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::angle_between(
[INFO] [stdout] 164 |                                 _self.into_inner(),
[INFO] [stdout] 165 |                                 rhs.into_inner(),
[INFO] [stdout] 166 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:249:43
[INFO] [stdout]     |
[INFO] [stdout] 249 |                           let output: f32 = ::glam::Quat::dot(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 250 | |                                 _self.into_inner(),
[INFO] [stdout] 251 | |                                 rhs.into_inner(),
[INFO] [stdout] 252 | |                             )
[INFO] [stdout] 253 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -                             )
[INFO] [stdout] 253 -                             .into();
[INFO] [stdout] 252 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::dot(
[INFO] [stdout] 250 |                                 _self.into_inner(),
[INFO] [stdout] 251 |                                 rhs.into_inner(),
[INFO] [stdout] 252 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:42:44
[INFO] [stdout]    |
[INFO] [stdout] 42 |                           let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ____________________________________________^
[INFO] [stdout] 43 | |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 45 | |                             .into();
[INFO] [stdout]    | |___________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                         >>::eq(&_self, &other)
[INFO] [stdout] 45 -                             .into();
[INFO] [stdout] 44 +                         >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 ~                         let output: bool = <bool as Into<_>>::into(<::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout] 43 |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 ~                         >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:267:44
[INFO] [stdout]     |
[INFO] [stdout] 267 |                           let output: bool = <::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 268 | |                             ::glam::Quat,
[INFO] [stdout] 269 | |                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 -                             .into();
[INFO] [stdout] 269 +                         >>::eq(&_self, &rhs);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout] 268 |                             ::glam::Quat,
[INFO] [stdout] 269 ~                         >>::eq(&_self, &rhs));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:84:40
[INFO] [stdout]    |
[INFO] [stdout] 84 |                       let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 85 | |                         ::core::any::TypeId,
[INFO] [stdout] 86 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 87 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -                     >>::eq(&_self, &other)
[INFO] [stdout] 87 -                     .into();
[INFO] [stdout] 86 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 ~                     let output: bool = <bool as Into<_>>::into(<::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout] 85 |                         ::core::any::TypeId,
[INFO] [stdout] 86 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:601:44
[INFO] [stdout]     |
[INFO] [stdout] 601 |                           let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 602 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = ::glam::Quat::is_finite(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_finite(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:616:44
[INFO] [stdout]     |
[INFO] [stdout] 616 |                           let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 617 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = ::glam::Quat::is_nan(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_nan(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:110:44
[INFO] [stdout]     |
[INFO] [stdout] 110 |                           let output: bool = ::glam::Quat::abs_diff_eq(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 111 | |                                 _self.into_inner(),
[INFO] [stdout] 112 | |                                 rhs.into_inner(),
[INFO] [stdout] 113 | |                                 max_abs_diff,
[INFO] [stdout] 114 | |                             )
[INFO] [stdout] 115 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -                             )
[INFO] [stdout] 115 -                             .into();
[INFO] [stdout] 114 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::abs_diff_eq(
[INFO] [stdout] 111 |                                 _self.into_inner(),
[INFO] [stdout] 112 |                                 rhs.into_inner(),
[INFO] [stdout] 113 |                                 max_abs_diff,
[INFO] [stdout] 114 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:631:44
[INFO] [stdout]     |
[INFO] [stdout] 631 |                           let output: bool = ::glam::Quat::is_near_identity(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 632 | |                                 _self.into_inner(),
[INFO] [stdout] 633 | |                             )
[INFO] [stdout] 634 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 633 -                             )
[INFO] [stdout] 634 -                             .into();
[INFO] [stdout] 633 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 631 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_near_identity(
[INFO] [stdout] 632 |                                 _self.into_inner(),
[INFO] [stdout] 633 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:648:44
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           let output: bool = ::glam::Quat::is_normalized(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 649 | |                                 _self.into_inner(),
[INFO] [stdout] 650 | |                             )
[INFO] [stdout] 651 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 650 -                             )
[INFO] [stdout] 651 -                             .into();
[INFO] [stdout] 650 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 648 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_normalized(
[INFO] [stdout] 649 |                                 _self.into_inner(),
[INFO] [stdout] 650 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:163:43
[INFO] [stdout]     |
[INFO] [stdout] 163 |                           let output: f32 = ::glam::Quat::angle_between(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 164 | |                                 _self.into_inner(),
[INFO] [stdout] 165 | |                                 rhs.into_inner(),
[INFO] [stdout] 166 | |                             )
[INFO] [stdout] 167 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -                             )
[INFO] [stdout] 167 -                             .into();
[INFO] [stdout] 166 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::angle_between(
[INFO] [stdout] 164 |                                 _self.into_inner(),
[INFO] [stdout] 165 |                                 rhs.into_inner(),
[INFO] [stdout] 166 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:665:43
[INFO] [stdout]     |
[INFO] [stdout] 665 |                           let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 666 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = ::glam::Quat::length(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:680:43
[INFO] [stdout]     |
[INFO] [stdout] 680 |                           let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 681 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_recip(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:249:43
[INFO] [stdout]     |
[INFO] [stdout] 249 |                           let output: f32 = ::glam::Quat::dot(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 250 | |                                 _self.into_inner(),
[INFO] [stdout] 251 | |                                 rhs.into_inner(),
[INFO] [stdout] 252 | |                             )
[INFO] [stdout] 253 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -                             )
[INFO] [stdout] 253 -                             .into();
[INFO] [stdout] 252 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::dot(
[INFO] [stdout] 250 |                                 _self.into_inner(),
[INFO] [stdout] 251 |                                 rhs.into_inner(),
[INFO] [stdout] 252 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:695:43
[INFO] [stdout]     |
[INFO] [stdout] 695 |                           let output: f32 = ::glam::Quat::length_squared(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 696 | |                                 _self.into_inner(),
[INFO] [stdout] 697 | |                             )
[INFO] [stdout] 698 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -                             )
[INFO] [stdout] 698 -                             .into();
[INFO] [stdout] 697 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_squared(
[INFO] [stdout] 696 |                                 _self.into_inner(),
[INFO] [stdout] 697 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:267:44
[INFO] [stdout]     |
[INFO] [stdout] 267 |                           let output: bool = <::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 268 | |                             ::glam::Quat,
[INFO] [stdout] 269 | |                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 -                             .into();
[INFO] [stdout] 269 +                         >>::eq(&_self, &rhs);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout] 268 |                             ::glam::Quat,
[INFO] [stdout] 269 ~                         >>::eq(&_self, &rhs));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 4]`
[INFO] [stdout]     --> src/lib.rs:1069:48
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = ::glam::Quat::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = <[f32; 4] as Into<_>>::into(::glam::Quat::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:601:44
[INFO] [stdout]     |
[INFO] [stdout] 601 |                           let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 602 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = ::glam::Quat::is_finite(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_finite(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `(f32, f32, f32)`
[INFO] [stdout]     --> src/lib.rs:1083:55
[INFO] [stdout]      |
[INFO] [stdout] 1083 |                           let output: (f32, f32, f32) = ::glam::Quat::to_euler(
[INFO] [stdout]      |  _______________________________________________________^
[INFO] [stdout] 1084 | |                                 _self.into_inner(),
[INFO] [stdout] 1085 | |                                 order.into_inner(),
[INFO] [stdout] 1086 | |                             )
[INFO] [stdout] 1087 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -                             )
[INFO] [stdout] 1087 -                             .into();
[INFO] [stdout] 1086 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 ~                         let output: (f32, f32, f32) = <(f32, f32, f32) as Into<_>>::into(::glam::Quat::to_euler(
[INFO] [stdout] 1084 |                                 _self.into_inner(),
[INFO] [stdout] 1085 |                                 order.into_inner(),
[INFO] [stdout] 1086 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:616:44
[INFO] [stdout]     |
[INFO] [stdout] 616 |                           let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 617 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = ::glam::Quat::is_nan(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_nan(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:631:44
[INFO] [stdout]     |
[INFO] [stdout] 631 |                           let output: bool = ::glam::Quat::is_near_identity(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 632 | |                                 _self.into_inner(),
[INFO] [stdout] 633 | |                             )
[INFO] [stdout] 634 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 633 -                             )
[INFO] [stdout] 634 -                             .into();
[INFO] [stdout] 633 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 631 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_near_identity(
[INFO] [stdout] 632 |                                 _self.into_inner(),
[INFO] [stdout] 633 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1160:44
[INFO] [stdout]      |
[INFO] [stdout] 1160 |                           let output: bool = ::glam::Vec3::abs_diff_eq(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1161 | |                                 _self.into_inner(),
[INFO] [stdout] 1162 | |                                 rhs.into_inner(),
[INFO] [stdout] 1163 | |                                 max_abs_diff,
[INFO] [stdout] 1164 | |                             )
[INFO] [stdout] 1165 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1164 -                             )
[INFO] [stdout] 1165 -                             .into();
[INFO] [stdout] 1164 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1160 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::abs_diff_eq(
[INFO] [stdout] 1161 |                                 _self.into_inner(),
[INFO] [stdout] 1162 |                                 rhs.into_inner(),
[INFO] [stdout] 1163 |                                 max_abs_diff,
[INFO] [stdout] 1164 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:648:44
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           let output: bool = ::glam::Quat::is_normalized(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 649 | |                                 _self.into_inner(),
[INFO] [stdout] 650 | |                             )
[INFO] [stdout] 651 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 650 -                             )
[INFO] [stdout] 651 -                             .into();
[INFO] [stdout] 650 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 648 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_normalized(
[INFO] [stdout] 649 |                                 _self.into_inner(),
[INFO] [stdout] 650 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1230:43
[INFO] [stdout]      |
[INFO] [stdout] 1230 |                           let output: f32 = ::glam::Vec3::angle_between(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1231 | |                                 _self.into_inner(),
[INFO] [stdout] 1232 | |                                 rhs.into_inner(),
[INFO] [stdout] 1233 | |                             )
[INFO] [stdout] 1234 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1233 -                             )
[INFO] [stdout] 1234 -                             .into();
[INFO] [stdout] 1233 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_between(
[INFO] [stdout] 1231 |                                 _self.into_inner(),
[INFO] [stdout] 1232 |                                 rhs.into_inner(),
[INFO] [stdout] 1233 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:665:43
[INFO] [stdout]     |
[INFO] [stdout] 665 |                           let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 666 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = ::glam::Quat::length(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1248:43
[INFO] [stdout]      |
[INFO] [stdout] 1248 |                           let output: f32 = ::glam::Vec3::angle_to(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1249 | |                                 _self.into_inner(),
[INFO] [stdout] 1250 | |                                 rhs.into_inner(),
[INFO] [stdout] 1251 | |                                 axis.into_inner(),
[INFO] [stdout] 1252 | |                             )
[INFO] [stdout] 1253 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1252 -                             )
[INFO] [stdout] 1253 -                             .into();
[INFO] [stdout] 1252 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_to(
[INFO] [stdout] 1249 |                                 _self.into_inner(),
[INFO] [stdout] 1250 |                                 rhs.into_inner(),
[INFO] [stdout] 1251 |                                 axis.into_inner(),
[INFO] [stdout] 1252 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:680:43
[INFO] [stdout]     |
[INFO] [stdout] 680 |                           let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 681 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_recip(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1723:43
[INFO] [stdout]      |
[INFO] [stdout] 1723 |                           let output: f32 = ::glam::Vec3::distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1724 | |                                 _self.into_inner(),
[INFO] [stdout] 1725 | |                                 rhs.into_inner(),
[INFO] [stdout] 1726 | |                             )
[INFO] [stdout] 1727 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1726 -                             )
[INFO] [stdout] 1727 -                             .into();
[INFO] [stdout] 1726 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1723 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance(
[INFO] [stdout] 1724 |                                 _self.into_inner(),
[INFO] [stdout] 1725 |                                 rhs.into_inner(),
[INFO] [stdout] 1726 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:695:43
[INFO] [stdout]     |
[INFO] [stdout] 695 |                           let output: f32 = ::glam::Quat::length_squared(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 696 | |                                 _self.into_inner(),
[INFO] [stdout] 697 | |                             )
[INFO] [stdout] 698 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -                             )
[INFO] [stdout] 698 -                             .into();
[INFO] [stdout] 697 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_squared(
[INFO] [stdout] 696 |                                 _self.into_inner(),
[INFO] [stdout] 697 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1741:43
[INFO] [stdout]      |
[INFO] [stdout] 1741 |                           let output: f32 = ::glam::Vec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1742 | |                                 _self.into_inner(),
[INFO] [stdout] 1743 | |                                 rhs.into_inner(),
[INFO] [stdout] 1744 | |                             )
[INFO] [stdout] 1745 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1744 -                             )
[INFO] [stdout] 1745 -                             .into();
[INFO] [stdout] 1744 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1741 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance_squared(
[INFO] [stdout] 1742 |                                 _self.into_inner(),
[INFO] [stdout] 1743 |                                 rhs.into_inner(),
[INFO] [stdout] 1744 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 4]`
[INFO] [stdout]     --> src/lib.rs:1069:48
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = ::glam::Quat::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = <[f32; 4] as Into<_>>::into(::glam::Quat::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1828:43
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                           let output: f32 = ::glam::Vec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1829 | |                                 _self.into_inner(),
[INFO] [stdout] 1830 | |                                 rhs.into_inner(),
[INFO] [stdout] 1831 | |                             )
[INFO] [stdout] 1832 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1831 -                             )
[INFO] [stdout] 1832 -                             .into();
[INFO] [stdout] 1831 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::dot(
[INFO] [stdout] 1829 |                                 _self.into_inner(),
[INFO] [stdout] 1830 |                                 rhs.into_inner(),
[INFO] [stdout] 1831 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `(f32, f32, f32)`
[INFO] [stdout]     --> src/lib.rs:1083:55
[INFO] [stdout]      |
[INFO] [stdout] 1083 |                           let output: (f32, f32, f32) = ::glam::Quat::to_euler(
[INFO] [stdout]      |  _______________________________________________________^
[INFO] [stdout] 1084 | |                                 _self.into_inner(),
[INFO] [stdout] 1085 | |                                 order.into_inner(),
[INFO] [stdout] 1086 | |                             )
[INFO] [stdout] 1087 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -                             )
[INFO] [stdout] 1087 -                             .into();
[INFO] [stdout] 1086 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 ~                         let output: (f32, f32, f32) = <(f32, f32, f32) as Into<_>>::into(::glam::Quat::to_euler(
[INFO] [stdout] 1084 |                                 _self.into_inner(),
[INFO] [stdout] 1085 |                                 order.into_inner(),
[INFO] [stdout] 1086 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1864:43
[INFO] [stdout]      |
[INFO] [stdout] 1864 |                           let output: f32 = ::glam::Vec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1865 | |                                 _self.into_inner(),
[INFO] [stdout] 1866 | |                             )
[INFO] [stdout] 1867 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1866 -                             )
[INFO] [stdout] 1867 -                             .into();
[INFO] [stdout] 1866 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1864 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_product(
[INFO] [stdout] 1865 |                                 _self.into_inner(),
[INFO] [stdout] 1866 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1881:43
[INFO] [stdout]      |
[INFO] [stdout] 1881 |                           let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1882 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1896:44
[INFO] [stdout]      |
[INFO] [stdout] 1896 |                           let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1897 | |                             ::glam::Vec3,
[INFO] [stdout] 1898 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 -                             .into();
[INFO] [stdout] 1898 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1896 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 1897 |                             ::glam::Vec3,
[INFO] [stdout] 1898 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2047:44
[INFO] [stdout]      |
[INFO] [stdout] 2047 |                           let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2048 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_finite(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2079:44
[INFO] [stdout]      |
[INFO] [stdout] 2079 |                           let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2080 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_nan(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:2111:43
[INFO] [stdout]      |
[INFO] [stdout] 2111 |                           let output: u32 = ::glam::Vec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2112 | |                                 _self.into_inner(),
[INFO] [stdout] 2113 | |                             )
[INFO] [stdout] 2114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2113 -                             )
[INFO] [stdout] 2114 -                             .into();
[INFO] [stdout] 2113 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2111 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::Vec3::is_negative_bitmask(
[INFO] [stdout] 2112 |                                 _self.into_inner(),
[INFO] [stdout] 2113 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2145:44
[INFO] [stdout]      |
[INFO] [stdout] 2145 |                           let output: bool = ::glam::Vec3::is_normalized(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2146 | |                                 _self.into_inner(),
[INFO] [stdout] 2147 | |                             )
[INFO] [stdout] 2148 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2147 -                             )
[INFO] [stdout] 2148 -                             .into();
[INFO] [stdout] 2147 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2145 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_normalized(
[INFO] [stdout] 2146 |                                 _self.into_inner(),
[INFO] [stdout] 2147 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2162:43
[INFO] [stdout]      |
[INFO] [stdout] 2162 |                           let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2163 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = ::glam::Vec3::length(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2177:43
[INFO] [stdout]      |
[INFO] [stdout] 2177 |                           let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2178 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_recip(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1160:44
[INFO] [stdout]      |
[INFO] [stdout] 1160 |                           let output: bool = ::glam::Vec3::abs_diff_eq(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1161 | |                                 _self.into_inner(),
[INFO] [stdout] 1162 | |                                 rhs.into_inner(),
[INFO] [stdout] 1163 | |                                 max_abs_diff,
[INFO] [stdout] 1164 | |                             )
[INFO] [stdout] 1165 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1164 -                             )
[INFO] [stdout] 1165 -                             .into();
[INFO] [stdout] 1164 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1160 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::abs_diff_eq(
[INFO] [stdout] 1161 |                                 _self.into_inner(),
[INFO] [stdout] 1162 |                                 rhs.into_inner(),
[INFO] [stdout] 1163 |                                 max_abs_diff,
[INFO] [stdout] 1164 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2192:43
[INFO] [stdout]      |
[INFO] [stdout] 2192 |                           let output: f32 = ::glam::Vec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2193 | |                                 _self.into_inner(),
[INFO] [stdout] 2194 | |                             )
[INFO] [stdout] 2195 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2194 -                             )
[INFO] [stdout] 2195 -                             .into();
[INFO] [stdout] 2194 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2192 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_squared(
[INFO] [stdout] 2193 |                                 _self.into_inner(),
[INFO] [stdout] 2194 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1230:43
[INFO] [stdout]      |
[INFO] [stdout] 1230 |                           let output: f32 = ::glam::Vec3::angle_between(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1231 | |                                 _self.into_inner(),
[INFO] [stdout] 1232 | |                                 rhs.into_inner(),
[INFO] [stdout] 1233 | |                             )
[INFO] [stdout] 1234 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1233 -                             )
[INFO] [stdout] 1234 -                             .into();
[INFO] [stdout] 1233 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_between(
[INFO] [stdout] 1231 |                                 _self.into_inner(),
[INFO] [stdout] 1232 |                                 rhs.into_inner(),
[INFO] [stdout] 1233 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2299:43
[INFO] [stdout]      |
[INFO] [stdout] 2299 |                           let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2300 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1248:43
[INFO] [stdout]      |
[INFO] [stdout] 1248 |                           let output: f32 = ::glam::Vec3::angle_to(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1249 | |                                 _self.into_inner(),
[INFO] [stdout] 1250 | |                                 rhs.into_inner(),
[INFO] [stdout] 1251 | |                                 axis.into_inner(),
[INFO] [stdout] 1252 | |                             )
[INFO] [stdout] 1253 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1252 -                             )
[INFO] [stdout] 1253 -                             .into();
[INFO] [stdout] 1252 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_to(
[INFO] [stdout] 1249 |                                 _self.into_inner(),
[INFO] [stdout] 1250 |                                 rhs.into_inner(),
[INFO] [stdout] 1251 |                                 axis.into_inner(),
[INFO] [stdout] 1252 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2314:45
[INFO] [stdout]      |
[INFO] [stdout] 2314 |                           let output: usize = ::glam::Vec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2315 | |                                 _self.into_inner(),
[INFO] [stdout] 2316 | |                             )
[INFO] [stdout] 2317 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2316 -                             )
[INFO] [stdout] 2317 -                             .into();
[INFO] [stdout] 2316 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2314 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::max_position(
[INFO] [stdout] 2315 |                                 _self.into_inner(),
[INFO] [stdout] 2316 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2367:43
[INFO] [stdout]      |
[INFO] [stdout] 2367 |                           let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2368 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1723:43
[INFO] [stdout]      |
[INFO] [stdout] 1723 |                           let output: f32 = ::glam::Vec3::distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1724 | |                                 _self.into_inner(),
[INFO] [stdout] 1725 | |                                 rhs.into_inner(),
[INFO] [stdout] 1726 | |                             )
[INFO] [stdout] 1727 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1726 -                             )
[INFO] [stdout] 1727 -                             .into();
[INFO] [stdout] 1726 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1723 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance(
[INFO] [stdout] 1724 |                                 _self.into_inner(),
[INFO] [stdout] 1725 |                                 rhs.into_inner(),
[INFO] [stdout] 1726 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2382:45
[INFO] [stdout]      |
[INFO] [stdout] 2382 |                           let output: usize = ::glam::Vec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2383 | |                                 _self.into_inner(),
[INFO] [stdout] 2384 | |                             )
[INFO] [stdout] 2385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2384 -                             )
[INFO] [stdout] 2385 -                             .into();
[INFO] [stdout] 2384 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2382 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::min_position(
[INFO] [stdout] 2383 |                                 _self.into_inner(),
[INFO] [stdout] 2384 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1741:43
[INFO] [stdout]      |
[INFO] [stdout] 1741 |                           let output: f32 = ::glam::Vec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1742 | |                                 _self.into_inner(),
[INFO] [stdout] 1743 | |                                 rhs.into_inner(),
[INFO] [stdout] 1744 | |                             )
[INFO] [stdout] 1745 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1744 -                             )
[INFO] [stdout] 1745 -                             .into();
[INFO] [stdout] 1744 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1741 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance_squared(
[INFO] [stdout] 1742 |                                 _self.into_inner(),
[INFO] [stdout] 1743 |                                 rhs.into_inner(),
[INFO] [stdout] 1744 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1828:43
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                           let output: f32 = ::glam::Vec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1829 | |                                 _self.into_inner(),
[INFO] [stdout] 1830 | |                                 rhs.into_inner(),
[INFO] [stdout] 1831 | |                             )
[INFO] [stdout] 1832 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1831 -                             )
[INFO] [stdout] 1832 -                             .into();
[INFO] [stdout] 1831 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::dot(
[INFO] [stdout] 1829 |                                 _self.into_inner(),
[INFO] [stdout] 1830 |                                 rhs.into_inner(),
[INFO] [stdout] 1831 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 3]`
[INFO] [stdout]     --> src/lib.rs:3105:48
[INFO] [stdout]      |
[INFO] [stdout] 3105 |                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = <[f32; 3] as Into<_>>::into(::glam::Vec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1864:43
[INFO] [stdout]      |
[INFO] [stdout] 1864 |                           let output: f32 = ::glam::Vec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1865 | |                                 _self.into_inner(),
[INFO] [stdout] 1866 | |                             )
[INFO] [stdout] 1867 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1866 -                             )
[INFO] [stdout] 1867 -                             .into();
[INFO] [stdout] 1866 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1864 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_product(
[INFO] [stdout] 1865 |                                 _self.into_inner(),
[INFO] [stdout] 1866 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3265:40
[INFO] [stdout]      |
[INFO] [stdout] 3265 |                       let output: bool = <::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3267 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 -                     .into();
[INFO] [stdout] 3267 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3265 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1881:43
[INFO] [stdout]      |
[INFO] [stdout] 1881 |                           let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1882 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3326:44
[INFO] [stdout]      |
[INFO] [stdout] 3326 |                           let output: bool = <::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3327 | |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3328 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 -                             .into();
[INFO] [stdout] 3328 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3326 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout] 3327 |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1896:44
[INFO] [stdout]      |
[INFO] [stdout] 1896 |                           let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1897 | |                             ::glam::Vec3,
[INFO] [stdout] 1898 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 -                             .into();
[INFO] [stdout] 1898 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1896 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 1897 |                             ::glam::Vec3,
[INFO] [stdout] 1898 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3442:44
[INFO] [stdout]      |
[INFO] [stdout] 3442 |                           let output: bool = <::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3443 | |                             ::std::time::Instant,
[INFO] [stdout] 3444 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3444 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 -                             .into();
[INFO] [stdout] 3444 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3442 ~                         let output: bool = <bool as Into<_>>::into(<::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout] 3443 |                             ::std::time::Instant,
[INFO] [stdout] 3444 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2047:44
[INFO] [stdout]      |
[INFO] [stdout] 2047 |                           let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2048 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_finite(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3552:44
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                           let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3553 | |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3554 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 -                             .into();
[INFO] [stdout] 3554 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 ~                         let output: bool = <bool as Into<_>>::into(<::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout] 3553 |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2079:44
[INFO] [stdout]      |
[INFO] [stdout] 2079 |                           let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2080 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_nan(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3569:44
[INFO] [stdout]      |
[INFO] [stdout] 3569 |                           let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3570 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv4(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:2111:43
[INFO] [stdout]      |
[INFO] [stdout] 2111 |                           let output: u32 = ::glam::Vec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2112 | |                                 _self.into_inner(),
[INFO] [stdout] 2113 | |                             )
[INFO] [stdout] 2114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2113 -                             )
[INFO] [stdout] 2114 -                             .into();
[INFO] [stdout] 2113 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2111 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::Vec3::is_negative_bitmask(
[INFO] [stdout] 2112 |                                 _self.into_inner(),
[INFO] [stdout] 2113 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3584:44
[INFO] [stdout]      |
[INFO] [stdout] 3584 |                           let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3585 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv6(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/lib.rs:3599:43
[INFO] [stdout]      |
[INFO] [stdout] 3599 |                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = ::core::net::SocketAddr::port(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = <u16 as Into<_>>::into(::core::net::SocketAddr::port(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:3613:42
[INFO] [stdout]      |
[INFO] [stdout] 3613 |                           let output: () = ::core::net::SocketAddr::set_port(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 3614 | |                                 &mut _self,
[INFO] [stdout] 3615 | |                                 new_port,
[INFO] [stdout] 3616 | |                             )
[INFO] [stdout] 3617 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3616 -                             )
[INFO] [stdout] 3617 -                             .into();
[INFO] [stdout] 3616 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3613 ~                         let output: () = <() as Into<_>>::into(::core::net::SocketAddr::set_port(
[INFO] [stdout] 3614 |                                 &mut _self,
[INFO] [stdout] 3615 |                                 new_port,
[INFO] [stdout] 3616 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2145:44
[INFO] [stdout]      |
[INFO] [stdout] 2145 |                           let output: bool = ::glam::Vec3::is_normalized(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2146 | |                                 _self.into_inner(),
[INFO] [stdout] 2147 | |                             )
[INFO] [stdout] 2148 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2147 -                             )
[INFO] [stdout] 2148 -                             .into();
[INFO] [stdout] 2147 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2145 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_normalized(
[INFO] [stdout] 2146 |                                 _self.into_inner(),
[INFO] [stdout] 2147 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2162:43
[INFO] [stdout]      |
[INFO] [stdout] 2162 |                           let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2163 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = ::glam::Vec3::length(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2177:43
[INFO] [stdout]      |
[INFO] [stdout] 2177 |                           let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2178 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_recip(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2192:43
[INFO] [stdout]      |
[INFO] [stdout] 2192 |                           let output: f32 = ::glam::Vec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2193 | |                                 _self.into_inner(),
[INFO] [stdout] 2194 | |                             )
[INFO] [stdout] 2195 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2194 -                             )
[INFO] [stdout] 2195 -                             .into();
[INFO] [stdout] 2194 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2192 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_squared(
[INFO] [stdout] 2193 |                                 _self.into_inner(),
[INFO] [stdout] 2194 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2299:43
[INFO] [stdout]      |
[INFO] [stdout] 2299 |                           let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2300 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2314:45
[INFO] [stdout]      |
[INFO] [stdout] 2314 |                           let output: usize = ::glam::Vec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2315 | |                                 _self.into_inner(),
[INFO] [stdout] 2316 | |                             )
[INFO] [stdout] 2317 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2316 -                             )
[INFO] [stdout] 2317 -                             .into();
[INFO] [stdout] 2316 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2314 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::max_position(
[INFO] [stdout] 2315 |                                 _self.into_inner(),
[INFO] [stdout] 2316 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3678:44
[INFO] [stdout]      |
[INFO] [stdout] 3678 |                           let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3679 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = ::core::time::Duration::as_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3693:44
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                           let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3694 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = ::core::time::Duration::as_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3708:44
[INFO] [stdout]      |
[INFO] [stdout] 3708 |                           let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3709 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = ::core::time::Duration::as_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/lib.rs:3723:43
[INFO] [stdout]      |
[INFO] [stdout] 3723 |                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = ::core::time::Duration::as_secs(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = <u64 as Into<_>>::into(::core::time::Duration::as_secs(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3737:43
[INFO] [stdout]      |
[INFO] [stdout] 3737 |                           let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3738 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::as_secs_f32(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3752:43
[INFO] [stdout]      |
[INFO] [stdout] 3752 |                           let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3753 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::as_secs_f64(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3801:43
[INFO] [stdout]      |
[INFO] [stdout] 3801 |                           let output: f32 = ::core::time::Duration::div_duration_f32(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3802 | |                                 _self.into_inner(),
[INFO] [stdout] 3803 | |                                 rhs.into_inner(),
[INFO] [stdout] 3804 | |                             )
[INFO] [stdout] 3805 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3804 -                             )
[INFO] [stdout] 3805 -                             .into();
[INFO] [stdout] 3804 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3801 ~                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::div_duration_f32(
[INFO] [stdout] 3802 |                                 _self.into_inner(),
[INFO] [stdout] 3803 |                                 rhs.into_inner(),
[INFO] [stdout] 3804 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3819:43
[INFO] [stdout]      |
[INFO] [stdout] 3819 |                           let output: f64 = ::core::time::Duration::div_duration_f64(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3820 | |                                 _self.into_inner(),
[INFO] [stdout] 3821 | |                                 rhs.into_inner(),
[INFO] [stdout] 3822 | |                             )
[INFO] [stdout] 3823 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3822 -                             )
[INFO] [stdout] 3823 -                             .into();
[INFO] [stdout] 3822 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3819 ~                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::div_duration_f64(
[INFO] [stdout] 3820 |                                 _self.into_inner(),
[INFO] [stdout] 3821 |                                 rhs.into_inner(),
[INFO] [stdout] 3822 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3873:44
[INFO] [stdout]      |
[INFO] [stdout] 3873 |                           let output: bool = <::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3874 | |                             ::core::time::Duration,
[INFO] [stdout] 3875 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3875 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 -                             .into();
[INFO] [stdout] 3875 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3873 ~                         let output: bool = <bool as Into<_>>::into(<::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout] 3874 |                             ::core::time::Duration,
[INFO] [stdout] 3875 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4043:44
[INFO] [stdout]      |
[INFO] [stdout] 4043 |                           let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4044 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = ::core::time::Duration::is_zero(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = <bool as Into<_>>::into(::core::time::Duration::is_zero(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2367:43
[INFO] [stdout]      |
[INFO] [stdout] 2367 |                           let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2368 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2382:45
[INFO] [stdout]      |
[INFO] [stdout] 2382 |                           let output: usize = ::glam::Vec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2383 | |                                 _self.into_inner(),
[INFO] [stdout] 2384 | |                             )
[INFO] [stdout] 2385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2384 -                             )
[INFO] [stdout] 2385 -                             .into();
[INFO] [stdout] 2384 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2382 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::min_position(
[INFO] [stdout] 2383 |                                 _self.into_inner(),
[INFO] [stdout] 2384 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4200:43
[INFO] [stdout]      |
[INFO] [stdout] 4200 |                           let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4201 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = ::core::time::Duration::subsec_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 3]`
[INFO] [stdout]     --> src/lib.rs:3105:48
[INFO] [stdout]      |
[INFO] [stdout] 3105 |                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = <[f32; 3] as Into<_>>::into(::glam::Vec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3265:40
[INFO] [stdout]      |
[INFO] [stdout] 3265 |                       let output: bool = <::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3267 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 -                     .into();
[INFO] [stdout] 3267 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3265 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3326:44
[INFO] [stdout]      |
[INFO] [stdout] 3326 |                           let output: bool = <::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3327 | |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3328 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 -                             .into();
[INFO] [stdout] 3328 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3326 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout] 3327 |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4215:43
[INFO] [stdout]      |
[INFO] [stdout] 4215 |                           let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4216 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = ::core::time::Duration::subsec_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3442:44
[INFO] [stdout]      |
[INFO] [stdout] 3442 |                           let output: bool = <::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3443 | |                             ::std::time::Instant,
[INFO] [stdout] 3444 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3444 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 -                             .into();
[INFO] [stdout] 3444 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3442 ~                         let output: bool = <bool as Into<_>>::into(<::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout] 3443 |                             ::std::time::Instant,
[INFO] [stdout] 3444 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3552:44
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                           let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3553 | |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3554 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 -                             .into();
[INFO] [stdout] 3554 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 ~                         let output: bool = <bool as Into<_>>::into(<::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout] 3553 |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3569:44
[INFO] [stdout]      |
[INFO] [stdout] 3569 |                           let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3570 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv4(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4230:43
[INFO] [stdout]      |
[INFO] [stdout] 4230 |                           let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4231 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3584:44
[INFO] [stdout]      |
[INFO] [stdout] 3584 |                           let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3585 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv6(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/lib.rs:3599:43
[INFO] [stdout]      |
[INFO] [stdout] 3599 |                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = ::core::net::SocketAddr::port(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = <u16 as Into<_>>::into(::core::net::SocketAddr::port(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:3613:42
[INFO] [stdout]      |
[INFO] [stdout] 3613 |                           let output: () = ::core::net::SocketAddr::set_port(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 3614 | |                                 &mut _self,
[INFO] [stdout] 3615 | |                                 new_port,
[INFO] [stdout] 3616 | |                             )
[INFO] [stdout] 3617 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3616 -                             )
[INFO] [stdout] 3617 -                             .into();
[INFO] [stdout] 3616 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3613 ~                         let output: () = <() as Into<_>>::into(::core::net::SocketAddr::set_port(
[INFO] [stdout] 3614 |                                 &mut _self,
[INFO] [stdout] 3615 |                                 new_port,
[INFO] [stdout] 3616 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4476:43
[INFO] [stdout]      |
[INFO] [stdout] 4476 |                           let output: u32 = ::glam::IVec2::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4477 | |                                 _self.into_inner(),
[INFO] [stdout] 4478 | |                                 rhs.into_inner(),
[INFO] [stdout] 4479 | |                             )
[INFO] [stdout] 4480 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4479 -                             )
[INFO] [stdout] 4480 -                             .into();
[INFO] [stdout] 4479 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4476 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::chebyshev_distance(
[INFO] [stdout] 4477 |                                 _self.into_inner(),
[INFO] [stdout] 4478 |                                 rhs.into_inner(),
[INFO] [stdout] 4479 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3678:44
[INFO] [stdout]      |
[INFO] [stdout] 3678 |                           let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3679 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = ::core::time::Duration::as_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3693:44
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                           let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3694 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = ::core::time::Duration::as_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3708:44
[INFO] [stdout]      |
[INFO] [stdout] 3708 |                           let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3709 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = ::core::time::Duration::as_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/lib.rs:3723:43
[INFO] [stdout]      |
[INFO] [stdout] 3723 |                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = ::core::time::Duration::as_secs(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = <u64 as Into<_>>::into(::core::time::Duration::as_secs(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3737:43
[INFO] [stdout]      |
[INFO] [stdout] 3737 |                           let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3738 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::as_secs_f32(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3752:43
[INFO] [stdout]      |
[INFO] [stdout] 3752 |                           let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3753 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::as_secs_f64(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3801:43
[INFO] [stdout]      |
[INFO] [stdout] 3801 |                           let output: f32 = ::core::time::Duration::div_duration_f32(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3802 | |                                 _self.into_inner(),
[INFO] [stdout] 3803 | |                                 rhs.into_inner(),
[INFO] [stdout] 3804 | |                             )
[INFO] [stdout] 3805 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3804 -                             )
[INFO] [stdout] 3805 -                             .into();
[INFO] [stdout] 3804 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3801 ~                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::div_duration_f32(
[INFO] [stdout] 3802 |                                 _self.into_inner(),
[INFO] [stdout] 3803 |                                 rhs.into_inner(),
[INFO] [stdout] 3804 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3819:43
[INFO] [stdout]      |
[INFO] [stdout] 3819 |                           let output: f64 = ::core::time::Duration::div_duration_f64(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3820 | |                                 _self.into_inner(),
[INFO] [stdout] 3821 | |                                 rhs.into_inner(),
[INFO] [stdout] 3822 | |                             )
[INFO] [stdout] 3823 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3822 -                             )
[INFO] [stdout] 3823 -                             .into();
[INFO] [stdout] 3822 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3819 ~                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::div_duration_f64(
[INFO] [stdout] 3820 |                                 _self.into_inner(),
[INFO] [stdout] 3821 |                                 rhs.into_inner(),
[INFO] [stdout] 3822 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3873:44
[INFO] [stdout]      |
[INFO] [stdout] 3873 |                           let output: bool = <::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3874 | |                             ::core::time::Duration,
[INFO] [stdout] 3875 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3875 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 -                             .into();
[INFO] [stdout] 3875 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3873 ~                         let output: bool = <bool as Into<_>>::into(<::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout] 3874 |                             ::core::time::Duration,
[INFO] [stdout] 3875 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4043:44
[INFO] [stdout]      |
[INFO] [stdout] 4043 |                           let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4044 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = ::core::time::Duration::is_zero(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = <bool as Into<_>>::into(::core::time::Duration::is_zero(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4200:43
[INFO] [stdout]      |
[INFO] [stdout] 4200 |                           let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4201 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = ::core::time::Duration::subsec_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4215:43
[INFO] [stdout]      |
[INFO] [stdout] 4215 |                           let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4216 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = ::core::time::Duration::subsec_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4230:43
[INFO] [stdout]      |
[INFO] [stdout] 4230 |                           let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4231 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4476:43
[INFO] [stdout]      |
[INFO] [stdout] 4476 |                           let output: u32 = ::glam::IVec2::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4477 | |                                 _self.into_inner(),
[INFO] [stdout] 4478 | |                                 rhs.into_inner(),
[INFO] [stdout] 4479 | |                             )
[INFO] [stdout] 4480 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4479 -                             )
[INFO] [stdout] 4480 -                             .into();
[INFO] [stdout] 4479 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4476 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::chebyshev_distance(
[INFO] [stdout] 4477 |                                 _self.into_inner(),
[INFO] [stdout] 4478 |                                 rhs.into_inner(),
[INFO] [stdout] 4479 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:4494:67
[INFO] [stdout]      |
[INFO] [stdout] 4494 |                           let output: ::core::option::Option<u32> = ::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 4495 | |                                 _self.into_inner(),
[INFO] [stdout] 4496 | |                                 rhs.into_inner(),
[INFO] [stdout] 4497 | |                             )
[INFO] [stdout] 4498 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4497 -                             )
[INFO] [stdout] 4498 -                             .into();
[INFO] [stdout] 4497 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4494 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout] 4495 |                                 _self.into_inner(),
[INFO] [stdout] 4496 |                                 rhs.into_inner(),
[INFO] [stdout] 4497 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4656:43
[INFO] [stdout]      |
[INFO] [stdout] 4656 |                           let output: i32 = ::glam::IVec2::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4657 | |                                 _self.into_inner(),
[INFO] [stdout] 4658 | |                                 rhs.into_inner(),
[INFO] [stdout] 4659 | |                             )
[INFO] [stdout] 4660 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4659 -                             )
[INFO] [stdout] 4660 -                             .into();
[INFO] [stdout] 4659 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4656 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::distance_squared(
[INFO] [stdout] 4657 |                                 _self.into_inner(),
[INFO] [stdout] 4658 |                                 rhs.into_inner(),
[INFO] [stdout] 4659 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4743:43
[INFO] [stdout]      |
[INFO] [stdout] 4743 |                           let output: i32 = ::glam::IVec2::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4744 | |                                 _self.into_inner(),
[INFO] [stdout] 4745 | |                                 rhs.into_inner(),
[INFO] [stdout] 4746 | |                             )
[INFO] [stdout] 4747 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4746 -                             )
[INFO] [stdout] 4747 -                             .into();
[INFO] [stdout] 4746 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4743 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::dot(
[INFO] [stdout] 4744 |                                 _self.into_inner(),
[INFO] [stdout] 4745 |                                 rhs.into_inner(),
[INFO] [stdout] 4746 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:4494:67
[INFO] [stdout]      |
[INFO] [stdout] 4494 |                           let output: ::core::option::Option<u32> = ::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 4495 | |                                 _self.into_inner(),
[INFO] [stdout] 4496 | |                                 rhs.into_inner(),
[INFO] [stdout] 4497 | |                             )
[INFO] [stdout] 4498 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4497 -                             )
[INFO] [stdout] 4498 -                             .into();
[INFO] [stdout] 4497 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4494 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout] 4495 |                                 _self.into_inner(),
[INFO] [stdout] 4496 |                                 rhs.into_inner(),
[INFO] [stdout] 4497 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4779:43
[INFO] [stdout]      |
[INFO] [stdout] 4779 |                           let output: i32 = ::glam::IVec2::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4780 | |                                 _self.into_inner(),
[INFO] [stdout] 4781 | |                             )
[INFO] [stdout] 4782 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4781 -                             )
[INFO] [stdout] 4782 -                             .into();
[INFO] [stdout] 4781 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4779 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_product(
[INFO] [stdout] 4780 |                                 _self.into_inner(),
[INFO] [stdout] 4781 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4656:43
[INFO] [stdout]      |
[INFO] [stdout] 4656 |                           let output: i32 = ::glam::IVec2::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4657 | |                                 _self.into_inner(),
[INFO] [stdout] 4658 | |                                 rhs.into_inner(),
[INFO] [stdout] 4659 | |                             )
[INFO] [stdout] 4660 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4659 -                             )
[INFO] [stdout] 4660 -                             .into();
[INFO] [stdout] 4659 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4656 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::distance_squared(
[INFO] [stdout] 4657 |                                 _self.into_inner(),
[INFO] [stdout] 4658 |                                 rhs.into_inner(),
[INFO] [stdout] 4659 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4743:43
[INFO] [stdout]      |
[INFO] [stdout] 4743 |                           let output: i32 = ::glam::IVec2::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4744 | |                                 _self.into_inner(),
[INFO] [stdout] 4745 | |                                 rhs.into_inner(),
[INFO] [stdout] 4746 | |                             )
[INFO] [stdout] 4747 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4746 -                             )
[INFO] [stdout] 4747 -                             .into();
[INFO] [stdout] 4746 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4743 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::dot(
[INFO] [stdout] 4744 |                                 _self.into_inner(),
[INFO] [stdout] 4745 |                                 rhs.into_inner(),
[INFO] [stdout] 4746 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4779:43
[INFO] [stdout]      |
[INFO] [stdout] 4779 |                           let output: i32 = ::glam::IVec2::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4780 | |                                 _self.into_inner(),
[INFO] [stdout] 4781 | |                             )
[INFO] [stdout] 4782 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4781 -                             )
[INFO] [stdout] 4782 -                             .into();
[INFO] [stdout] 4781 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4779 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_product(
[INFO] [stdout] 4780 |                                 _self.into_inner(),
[INFO] [stdout] 4781 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4796:43
[INFO] [stdout]      |
[INFO] [stdout] 4796 |                           let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4797 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4796:43
[INFO] [stdout]      |
[INFO] [stdout] 4796 |                           let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4797 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4811:44
[INFO] [stdout]      |
[INFO] [stdout] 4811 |                           let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4812 | |                             ::glam::IVec2,
[INFO] [stdout] 4813 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4813 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 -                             .into();
[INFO] [stdout] 4813 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4811 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 4812 |                             ::glam::IVec2,
[INFO] [stdout] 4813 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4861:43
[INFO] [stdout]      |
[INFO] [stdout] 4861 |                           let output: u32 = ::glam::IVec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4862 | |                                 _self.into_inner(),
[INFO] [stdout] 4863 | |                             )
[INFO] [stdout] 4864 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4863 -                             )
[INFO] [stdout] 4864 -                             .into();
[INFO] [stdout] 4863 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4861 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::is_negative_bitmask(
[INFO] [stdout] 4862 |                                 _self.into_inner(),
[INFO] [stdout] 4863 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4811:44
[INFO] [stdout]      |
[INFO] [stdout] 4811 |                           let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4812 | |                             ::glam::IVec2,
[INFO] [stdout] 4813 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4813 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 -                             .into();
[INFO] [stdout] 4813 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4811 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 4812 |                             ::glam::IVec2,
[INFO] [stdout] 4813 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4895:43
[INFO] [stdout]      |
[INFO] [stdout] 4895 |                           let output: i32 = ::glam::IVec2::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4896 | |                                 _self.into_inner(),
[INFO] [stdout] 4897 | |                             )
[INFO] [stdout] 4898 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4897 -                             )
[INFO] [stdout] 4898 -                             .into();
[INFO] [stdout] 4897 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4895 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::length_squared(
[INFO] [stdout] 4896 |                                 _self.into_inner(),
[INFO] [stdout] 4897 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4912:43
[INFO] [stdout]      |
[INFO] [stdout] 4912 |                           let output: u32 = ::glam::IVec2::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4913 | |                                 _self.into_inner(),
[INFO] [stdout] 4914 | |                                 rhs.into_inner(),
[INFO] [stdout] 4915 | |                             )
[INFO] [stdout] 4916 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4915 -                             )
[INFO] [stdout] 4916 -                             .into();
[INFO] [stdout] 4915 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4912 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::manhattan_distance(
[INFO] [stdout] 4913 |                                 _self.into_inner(),
[INFO] [stdout] 4914 |                                 rhs.into_inner(),
[INFO] [stdout] 4915 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4948:43
[INFO] [stdout]      |
[INFO] [stdout] 4948 |                           let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4949 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:4963:45
[INFO] [stdout]      |
[INFO] [stdout] 4963 |                           let output: usize = ::glam::IVec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 4964 | |                                 _self.into_inner(),
[INFO] [stdout] 4965 | |                             )
[INFO] [stdout] 4966 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4965 -                             )
[INFO] [stdout] 4966 -                             .into();
[INFO] [stdout] 4965 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4963 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::max_position(
[INFO] [stdout] 4964 |                                 _self.into_inner(),
[INFO] [stdout] 4965 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4998:43
[INFO] [stdout]      |
[INFO] [stdout] 4998 |                           let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4999 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:5013:45
[INFO] [stdout]      |
[INFO] [stdout] 5013 |                           let output: usize = ::glam::IVec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 5014 | |                                 _self.into_inner(),
[INFO] [stdout] 5015 | |                             )
[INFO] [stdout] 5016 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5015 -                             )
[INFO] [stdout] 5016 -                             .into();
[INFO] [stdout] 5015 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5013 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::min_position(
[INFO] [stdout] 5014 |                                 _self.into_inner(),
[INFO] [stdout] 5015 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:5129:43
[INFO] [stdout]      |
[INFO] [stdout] 5129 |                           let output: i32 = ::glam::IVec2::perp_dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5130 | |                                 _self.into_inner(),
[INFO] [stdout] 5131 | |                                 rhs.into_inner(),
[INFO] [stdout] 5132 | |                             )
[INFO] [stdout] 5133 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5132 -                             )
[INFO] [stdout] 5133 -                             .into();
[INFO] [stdout] 5132 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5129 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::perp_dot(
[INFO] [stdout] 5130 |                                 _self.into_inner(),
[INFO] [stdout] 5131 |                                 rhs.into_inner(),
[INFO] [stdout] 5132 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 2]`
[INFO] [stdout]     --> src/lib.rs:5447:48
[INFO] [stdout]      |
[INFO] [stdout] 5447 |                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = <[i32; 2] as Into<_>>::into(::glam::IVec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4861:43
[INFO] [stdout]      |
[INFO] [stdout] 4861 |                           let output: u32 = ::glam::IVec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4862 | |                                 _self.into_inner(),
[INFO] [stdout] 4863 | |                             )
[INFO] [stdout] 4864 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4863 -                             )
[INFO] [stdout] 4864 -                             .into();
[INFO] [stdout] 4863 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4861 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::is_negative_bitmask(
[INFO] [stdout] 4862 |                                 _self.into_inner(),
[INFO] [stdout] 4863 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4895:43
[INFO] [stdout]      |
[INFO] [stdout] 4895 |                           let output: i32 = ::glam::IVec2::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4896 | |                                 _self.into_inner(),
[INFO] [stdout] 4897 | |                             )
[INFO] [stdout] 4898 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4897 -                             )
[INFO] [stdout] 4898 -                             .into();
[INFO] [stdout] 4897 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4895 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::length_squared(
[INFO] [stdout] 4896 |                                 _self.into_inner(),
[INFO] [stdout] 4897 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:5851:43
[INFO] [stdout]      |
[INFO] [stdout] 5851 |                           let output: u32 = ::glam::IVec3::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5852 | |                                 _self.into_inner(),
[INFO] [stdout] 5853 | |                                 rhs.into_inner(),
[INFO] [stdout] 5854 | |                             )
[INFO] [stdout] 5855 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5854 -                             )
[INFO] [stdout] 5855 -                             .into();
[INFO] [stdout] 5854 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5851 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::chebyshev_distance(
[INFO] [stdout] 5852 |                                 _self.into_inner(),
[INFO] [stdout] 5853 |                                 rhs.into_inner(),
[INFO] [stdout] 5854 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4912:43
[INFO] [stdout]      |
[INFO] [stdout] 4912 |                           let output: u32 = ::glam::IVec2::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4913 | |                                 _self.into_inner(),
[INFO] [stdout] 4914 | |                                 rhs.into_inner(),
[INFO] [stdout] 4915 | |                             )
[INFO] [stdout] 4916 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4915 -                             )
[INFO] [stdout] 4916 -                             .into();
[INFO] [stdout] 4915 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4912 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::manhattan_distance(
[INFO] [stdout] 4913 |                                 _self.into_inner(),
[INFO] [stdout] 4914 |                                 rhs.into_inner(),
[INFO] [stdout] 4915 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:5869:67
[INFO] [stdout]      |
[INFO] [stdout] 5869 |                           let output: ::core::option::Option<u32> = ::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 5870 | |                                 _self.into_inner(),
[INFO] [stdout] 5871 | |                                 rhs.into_inner(),
[INFO] [stdout] 5872 | |                             )
[INFO] [stdout] 5873 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5872 -                             )
[INFO] [stdout] 5873 -                             .into();
[INFO] [stdout] 5872 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5869 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout] 5870 |                                 _self.into_inner(),
[INFO] [stdout] 5871 |                                 rhs.into_inner(),
[INFO] [stdout] 5872 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4948:43
[INFO] [stdout]      |
[INFO] [stdout] 4948 |                           let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4949 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:4963:45
[INFO] [stdout]      |
[INFO] [stdout] 4963 |                           let output: usize = ::glam::IVec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 4964 | |                                 _self.into_inner(),
[INFO] [stdout] 4965 | |                             )
[INFO] [stdout] 4966 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4965 -                             )
[INFO] [stdout] 4966 -                             .into();
[INFO] [stdout] 4965 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4963 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::max_position(
[INFO] [stdout] 4964 |                                 _self.into_inner(),
[INFO] [stdout] 4965 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6049:43
[INFO] [stdout]      |
[INFO] [stdout] 6049 |                           let output: i32 = ::glam::IVec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6050 | |                                 _self.into_inner(),
[INFO] [stdout] 6051 | |                                 rhs.into_inner(),
[INFO] [stdout] 6052 | |                             )
[INFO] [stdout] 6053 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6052 -                             )
[INFO] [stdout] 6053 -                             .into();
[INFO] [stdout] 6052 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6049 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::distance_squared(
[INFO] [stdout] 6050 |                                 _self.into_inner(),
[INFO] [stdout] 6051 |                                 rhs.into_inner(),
[INFO] [stdout] 6052 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6136:43
[INFO] [stdout]      |
[INFO] [stdout] 6136 |                           let output: i32 = ::glam::IVec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6137 | |                                 _self.into_inner(),
[INFO] [stdout] 6138 | |                                 rhs.into_inner(),
[INFO] [stdout] 6139 | |                             )
[INFO] [stdout] 6140 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6139 -                             )
[INFO] [stdout] 6140 -                             .into();
[INFO] [stdout] 6139 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6136 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::dot(
[INFO] [stdout] 6137 |                                 _self.into_inner(),
[INFO] [stdout] 6138 |                                 rhs.into_inner(),
[INFO] [stdout] 6139 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4998:43
[INFO] [stdout]      |
[INFO] [stdout] 4998 |                           let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4999 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6172:43
[INFO] [stdout]      |
[INFO] [stdout] 6172 |                           let output: i32 = ::glam::IVec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6173 | |                                 _self.into_inner(),
[INFO] [stdout] 6174 | |                             )
[INFO] [stdout] 6175 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6174 -                             )
[INFO] [stdout] 6175 -                             .into();
[INFO] [stdout] 6174 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6172 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_product(
[INFO] [stdout] 6173 |                                 _self.into_inner(),
[INFO] [stdout] 6174 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6189:43
[INFO] [stdout]      |
[INFO] [stdout] 6189 |                           let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6190 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:5013:45
[INFO] [stdout]      |
[INFO] [stdout] 5013 |                           let output: usize = ::glam::IVec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 5014 | |                                 _self.into_inner(),
[INFO] [stdout] 5015 | |                             )
[INFO] [stdout] 5016 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5015 -                             )
[INFO] [stdout] 5016 -                             .into();
[INFO] [stdout] 5015 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5013 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::min_position(
[INFO] [stdout] 5014 |                                 _self.into_inner(),
[INFO] [stdout] 5015 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6204:44
[INFO] [stdout]      |
[INFO] [stdout] 6204 |                           let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6205 | |                             ::glam::IVec3,
[INFO] [stdout] 6206 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6206 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 -                             .into();
[INFO] [stdout] 6206 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6204 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 6205 |                             ::glam::IVec3,
[INFO] [stdout] 6206 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:5129:43
[INFO] [stdout]      |
[INFO] [stdout] 5129 |                           let output: i32 = ::glam::IVec2::perp_dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5130 | |                                 _self.into_inner(),
[INFO] [stdout] 5131 | |                                 rhs.into_inner(),
[INFO] [stdout] 5132 | |                             )
[INFO] [stdout] 5133 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5132 -                             )
[INFO] [stdout] 5133 -                             .into();
[INFO] [stdout] 5132 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5129 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::perp_dot(
[INFO] [stdout] 5130 |                                 _self.into_inner(),
[INFO] [stdout] 5131 |                                 rhs.into_inner(),
[INFO] [stdout] 5132 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 2]`
[INFO] [stdout]     --> src/lib.rs:5447:48
[INFO] [stdout]      |
[INFO] [stdout] 5447 |                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = <[i32; 2] as Into<_>>::into(::glam::IVec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:5851:43
[INFO] [stdout]      |
[INFO] [stdout] 5851 |                           let output: u32 = ::glam::IVec3::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5852 | |                                 _self.into_inner(),
[INFO] [stdout] 5853 | |                                 rhs.into_inner(),
[INFO] [stdout] 5854 | |                             )
[INFO] [stdout] 5855 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5854 -                             )
[INFO] [stdout] 5855 -                             .into();
[INFO] [stdout] 5854 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5851 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::chebyshev_distance(
[INFO] [stdout] 5852 |                                 _self.into_inner(),
[INFO] [stdout] 5853 |                                 rhs.into_inner(),
[INFO] [stdout] 5854 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:5869:67
[INFO] [stdout]      |
[INFO] [stdout] 5869 |                           let output: ::core::option::Option<u32> = ::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 5870 | |                                 _self.into_inner(),
[INFO] [stdout] 5871 | |                                 rhs.into_inner(),
[INFO] [stdout] 5872 | |                             )
[INFO] [stdout] 5873 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5872 -                             )
[INFO] [stdout] 5873 -                             .into();
[INFO] [stdout] 5872 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5869 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout] 5870 |                                 _self.into_inner(),
[INFO] [stdout] 5871 |                                 rhs.into_inner(),
[INFO] [stdout] 5872 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6049:43
[INFO] [stdout]      |
[INFO] [stdout] 6049 |                           let output: i32 = ::glam::IVec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6050 | |                                 _self.into_inner(),
[INFO] [stdout] 6051 | |                                 rhs.into_inner(),
[INFO] [stdout] 6052 | |                             )
[INFO] [stdout] 6053 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6052 -                             )
[INFO] [stdout] 6053 -                             .into();
[INFO] [stdout] 6052 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6049 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::distance_squared(
[INFO] [stdout] 6050 |                                 _self.into_inner(),
[INFO] [stdout] 6051 |                                 rhs.into_inner(),
[INFO] [stdout] 6052 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6136:43
[INFO] [stdout]      |
[INFO] [stdout] 6136 |                           let output: i32 = ::glam::IVec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6137 | |                                 _self.into_inner(),
[INFO] [stdout] 6138 | |                                 rhs.into_inner(),
[INFO] [stdout] 6139 | |                             )
[INFO] [stdout] 6140 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6139 -                             )
[INFO] [stdout] 6140 -                             .into();
[INFO] [stdout] 6139 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6136 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::dot(
[INFO] [stdout] 6137 |                                 _self.into_inner(),
[INFO] [stdout] 6138 |                                 rhs.into_inner(),
[INFO] [stdout] 6139 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6172:43
[INFO] [stdout]      |
[INFO] [stdout] 6172 |                           let output: i32 = ::glam::IVec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6173 | |                                 _self.into_inner(),
[INFO] [stdout] 6174 | |                             )
[INFO] [stdout] 6175 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6174 -                             )
[INFO] [stdout] 6175 -                             .into();
[INFO] [stdout] 6174 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6172 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_product(
[INFO] [stdout] 6173 |                                 _self.into_inner(),
[INFO] [stdout] 6174 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6189:43
[INFO] [stdout]      |
[INFO] [stdout] 6189 |                           let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6190 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6204:44
[INFO] [stdout]      |
[INFO] [stdout] 6204 |                           let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6205 | |                             ::glam::IVec3,
[INFO] [stdout] 6206 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6206 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 -                             .into();
[INFO] [stdout] 6206 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6204 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 6205 |                             ::glam::IVec3,
[INFO] [stdout] 6206 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6254:43
[INFO] [stdout]      |
[INFO] [stdout] 6254 |                           let output: u32 = ::glam::IVec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6255 | |                                 _self.into_inner(),
[INFO] [stdout] 6256 | |                             )
[INFO] [stdout] 6257 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6256 -                             )
[INFO] [stdout] 6257 -                             .into();
[INFO] [stdout] 6256 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6254 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::is_negative_bitmask(
[INFO] [stdout] 6255 |                                 _self.into_inner(),
[INFO] [stdout] 6256 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6254:43
[INFO] [stdout]      |
[INFO] [stdout] 6254 |                           let output: u32 = ::glam::IVec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6255 | |                                 _self.into_inner(),
[INFO] [stdout] 6256 | |                             )
[INFO] [stdout] 6257 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6256 -                             )
[INFO] [stdout] 6257 -                             .into();
[INFO] [stdout] 6256 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6254 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::is_negative_bitmask(
[INFO] [stdout] 6255 |                                 _self.into_inner(),
[INFO] [stdout] 6256 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6288:43
[INFO] [stdout]      |
[INFO] [stdout] 6288 |                           let output: i32 = ::glam::IVec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6289 | |                                 _self.into_inner(),
[INFO] [stdout] 6290 | |                             )
[INFO] [stdout] 6291 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6290 -                             )
[INFO] [stdout] 6291 -                             .into();
[INFO] [stdout] 6290 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6288 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::length_squared(
[INFO] [stdout] 6289 |                                 _self.into_inner(),
[INFO] [stdout] 6290 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6288:43
[INFO] [stdout]      |
[INFO] [stdout] 6288 |                           let output: i32 = ::glam::IVec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6289 | |                                 _self.into_inner(),
[INFO] [stdout] 6290 | |                             )
[INFO] [stdout] 6291 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6290 -                             )
[INFO] [stdout] 6291 -                             .into();
[INFO] [stdout] 6290 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6288 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::length_squared(
[INFO] [stdout] 6289 |                                 _self.into_inner(),
[INFO] [stdout] 6290 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6305:43
[INFO] [stdout]      |
[INFO] [stdout] 6305 |                           let output: u32 = ::glam::IVec3::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6306 | |                                 _self.into_inner(),
[INFO] [stdout] 6307 | |                                 rhs.into_inner(),
[INFO] [stdout] 6308 | |                             )
[INFO] [stdout] 6309 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6308 -                             )
[INFO] [stdout] 6309 -                             .into();
[INFO] [stdout] 6308 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6305 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::manhattan_distance(
[INFO] [stdout] 6306 |                                 _self.into_inner(),
[INFO] [stdout] 6307 |                                 rhs.into_inner(),
[INFO] [stdout] 6308 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6341:43
[INFO] [stdout]      |
[INFO] [stdout] 6341 |                           let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6342 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6356:45
[INFO] [stdout]      |
[INFO] [stdout] 6356 |                           let output: usize = ::glam::IVec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6357 | |                                 _self.into_inner(),
[INFO] [stdout] 6358 | |                             )
[INFO] [stdout] 6359 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6358 -                             )
[INFO] [stdout] 6359 -                             .into();
[INFO] [stdout] 6358 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6356 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::max_position(
[INFO] [stdout] 6357 |                                 _self.into_inner(),
[INFO] [stdout] 6358 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6391:43
[INFO] [stdout]      |
[INFO] [stdout] 6391 |                           let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6392 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6406:45
[INFO] [stdout]      |
[INFO] [stdout] 6406 |                           let output: usize = ::glam::IVec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6407 | |                                 _self.into_inner(),
[INFO] [stdout] 6408 | |                             )
[INFO] [stdout] 6409 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6408 -                             )
[INFO] [stdout] 6409 -                             .into();
[INFO] [stdout] 6408 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6406 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::min_position(
[INFO] [stdout] 6407 |                                 _self.into_inner(),
[INFO] [stdout] 6408 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 3]`
[INFO] [stdout]     --> src/lib.rs:6788:48
[INFO] [stdout]      |
[INFO] [stdout] 6788 |                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = <[i32; 3] as Into<_>>::into(::glam::IVec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6305:43
[INFO] [stdout]      |
[INFO] [stdout] 6305 |                           let output: u32 = ::glam::IVec3::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6306 | |                                 _self.into_inner(),
[INFO] [stdout] 6307 | |                                 rhs.into_inner(),
[INFO] [stdout] 6308 | |                             )
[INFO] [stdout] 6309 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6308 -                             )
[INFO] [stdout] 6309 -                             .into();
[INFO] [stdout] 6308 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6305 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::manhattan_distance(
[INFO] [stdout] 6306 |                                 _self.into_inner(),
[INFO] [stdout] 6307 |                                 rhs.into_inner(),
[INFO] [stdout] 6308 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6341:43
[INFO] [stdout]      |
[INFO] [stdout] 6341 |                           let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6342 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7210:43
[INFO] [stdout]      |
[INFO] [stdout] 7210 |                           let output: u32 = ::glam::IVec4::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7211 | |                                 _self.into_inner(),
[INFO] [stdout] 7212 | |                                 rhs.into_inner(),
[INFO] [stdout] 7213 | |                             )
[INFO] [stdout] 7214 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7213 -                             )
[INFO] [stdout] 7214 -                             .into();
[INFO] [stdout] 7213 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7210 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::chebyshev_distance(
[INFO] [stdout] 7211 |                                 _self.into_inner(),
[INFO] [stdout] 7212 |                                 rhs.into_inner(),
[INFO] [stdout] 7213 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6356:45
[INFO] [stdout]      |
[INFO] [stdout] 6356 |                           let output: usize = ::glam::IVec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6357 | |                                 _self.into_inner(),
[INFO] [stdout] 6358 | |                             )
[INFO] [stdout] 6359 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6358 -                             )
[INFO] [stdout] 6359 -                             .into();
[INFO] [stdout] 6358 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6356 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::max_position(
[INFO] [stdout] 6357 |                                 _self.into_inner(),
[INFO] [stdout] 6358 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6391:43
[INFO] [stdout]      |
[INFO] [stdout] 6391 |                           let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6392 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:7228:67
[INFO] [stdout]      |
[INFO] [stdout] 7228 |                           let output: ::core::option::Option<u32> = ::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 7229 | |                                 _self.into_inner(),
[INFO] [stdout] 7230 | |                                 rhs.into_inner(),
[INFO] [stdout] 7231 | |                             )
[INFO] [stdout] 7232 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7231 -                             )
[INFO] [stdout] 7232 -                             .into();
[INFO] [stdout] 7231 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7228 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout] 7229 |                                 _self.into_inner(),
[INFO] [stdout] 7230 |                                 rhs.into_inner(),
[INFO] [stdout] 7231 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6406:45
[INFO] [stdout]      |
[INFO] [stdout] 6406 |                           let output: usize = ::glam::IVec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6407 | |                                 _self.into_inner(),
[INFO] [stdout] 6408 | |                             )
[INFO] [stdout] 6409 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6408 -                             )
[INFO] [stdout] 6409 -                             .into();
[INFO] [stdout] 6408 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6406 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::min_position(
[INFO] [stdout] 6407 |                                 _self.into_inner(),
[INFO] [stdout] 6408 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7390:43
[INFO] [stdout]      |
[INFO] [stdout] 7390 |                           let output: i32 = ::glam::IVec4::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7391 | |                                 _self.into_inner(),
[INFO] [stdout] 7392 | |                                 rhs.into_inner(),
[INFO] [stdout] 7393 | |                             )
[INFO] [stdout] 7394 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7393 -                             )
[INFO] [stdout] 7394 -                             .into();
[INFO] [stdout] 7393 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7390 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::distance_squared(
[INFO] [stdout] 7391 |                                 _self.into_inner(),
[INFO] [stdout] 7392 |                                 rhs.into_inner(),
[INFO] [stdout] 7393 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 3]`
[INFO] [stdout]     --> src/lib.rs:6788:48
[INFO] [stdout]      |
[INFO] [stdout] 6788 |                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = <[i32; 3] as Into<_>>::into(::glam::IVec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7477:43
[INFO] [stdout]      |
[INFO] [stdout] 7477 |                           let output: i32 = ::glam::IVec4::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7478 | |                                 _self.into_inner(),
[INFO] [stdout] 7479 | |                                 rhs.into_inner(),
[INFO] [stdout] 7480 | |                             )
[INFO] [stdout] 7481 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7480 -                             )
[INFO] [stdout] 7481 -                             .into();
[INFO] [stdout] 7480 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7477 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::dot(
[INFO] [stdout] 7478 |                                 _self.into_inner(),
[INFO] [stdout] 7479 |                                 rhs.into_inner(),
[INFO] [stdout] 7480 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7513:43
[INFO] [stdout]      |
[INFO] [stdout] 7513 |                           let output: i32 = ::glam::IVec4::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7514 | |                                 _self.into_inner(),
[INFO] [stdout] 7515 | |                             )
[INFO] [stdout] 7516 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7515 -                             )
[INFO] [stdout] 7516 -                             .into();
[INFO] [stdout] 7515 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7513 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_product(
[INFO] [stdout] 7514 |                                 _self.into_inner(),
[INFO] [stdout] 7515 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7210:43
[INFO] [stdout]      |
[INFO] [stdout] 7210 |                           let output: u32 = ::glam::IVec4::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7211 | |                                 _self.into_inner(),
[INFO] [stdout] 7212 | |                                 rhs.into_inner(),
[INFO] [stdout] 7213 | |                             )
[INFO] [stdout] 7214 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7213 -                             )
[INFO] [stdout] 7214 -                             .into();
[INFO] [stdout] 7213 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7210 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::chebyshev_distance(
[INFO] [stdout] 7211 |                                 _self.into_inner(),
[INFO] [stdout] 7212 |                                 rhs.into_inner(),
[INFO] [stdout] 7213 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7530:43
[INFO] [stdout]      |
[INFO] [stdout] 7530 |                           let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7531 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:7228:67
[INFO] [stdout]      |
[INFO] [stdout] 7228 |                           let output: ::core::option::Option<u32> = ::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 7229 | |                                 _self.into_inner(),
[INFO] [stdout] 7230 | |                                 rhs.into_inner(),
[INFO] [stdout] 7231 | |                             )
[INFO] [stdout] 7232 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7231 -                             )
[INFO] [stdout] 7232 -                             .into();
[INFO] [stdout] 7231 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7228 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout] 7229 |                                 _self.into_inner(),
[INFO] [stdout] 7230 |                                 rhs.into_inner(),
[INFO] [stdout] 7231 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:7545:44
[INFO] [stdout]      |
[INFO] [stdout] 7545 |                           let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 7546 | |                             ::glam::IVec4,
[INFO] [stdout] 7547 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7547 -                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 -                             .into();
[INFO] [stdout] 7547 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7545 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 7546 |                             ::glam::IVec4,
[INFO] [stdout] 7547 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7390:43
[INFO] [stdout]      |
[INFO] [stdout] 7390 |                           let output: i32 = ::glam::IVec4::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7391 | |                                 _self.into_inner(),
[INFO] [stdout] 7392 | |                                 rhs.into_inner(),
[INFO] [stdout] 7393 | |                             )
[INFO] [stdout] 7394 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7393 -                             )
[INFO] [stdout] 7394 -                             .into();
[INFO] [stdout] 7393 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7390 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::distance_squared(
[INFO] [stdout] 7391 |                                 _self.into_inner(),
[INFO] [stdout] 7392 |                                 rhs.into_inner(),
[INFO] [stdout] 7393 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7577:43
[INFO] [stdout]      |
[INFO] [stdout] 7577 |                           let output: u32 = ::glam::IVec4::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7578 | |                                 _self.into_inner(),
[INFO] [stdout] 7579 | |                             )
[INFO] [stdout] 7580 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7579 -                             )
[INFO] [stdout] 7580 -                             .into();
[INFO] [stdout] 7579 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7577 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::is_negative_bitmask(
[INFO] [stdout] 7578 |                                 _self.into_inner(),
[INFO] [stdout] 7579 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7477:43
[INFO] [stdout]      |
[INFO] [stdout] 7477 |                           let output: i32 = ::glam::IVec4::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7478 | |                                 _self.into_inner(),
[INFO] [stdout] 7479 | |                                 rhs.into_inner(),
[INFO] [stdout] 7480 | |                             )
[INFO] [stdout] 7481 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7480 -                             )
[INFO] [stdout] 7481 -                             .into();
[INFO] [stdout] 7480 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7477 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::dot(
[INFO] [stdout] 7478 |                                 _self.into_inner(),
[INFO] [stdout] 7479 |                                 rhs.into_inner(),
[INFO] [stdout] 7480 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7611:43
[INFO] [stdout]      |
[INFO] [stdout] 7611 |                           let output: i32 = ::glam::IVec4::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7612 | |                                 _self.into_inner(),
[INFO] [stdout] 7613 | |                             )
[INFO] [stdout] 7614 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7613 -                             )
[INFO] [stdout] 7614 -                             .into();
[INFO] [stdout] 7613 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7611 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::length_squared(
[INFO] [stdout] 7612 |                                 _self.into_inner(),
[INFO] [stdout] 7613 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7513:43
[INFO] [stdout]      |
[INFO] [stdout] 7513 |                           let output: i32 = ::glam::IVec4::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7514 | |                                 _self.into_inner(),
[INFO] [stdout] 7515 | |                             )
[INFO] [stdout] 7516 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7515 -                             )
[INFO] [stdout] 7516 -                             .into();
[INFO] [stdout] 7515 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7513 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_product(
[INFO] [stdout] 7514 |                                 _self.into_inner(),
[INFO] [stdout] 7515 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7628:43
[INFO] [stdout]      |
[INFO] [stdout] 7628 |                           let output: u32 = ::glam::IVec4::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7629 | |                                 _self.into_inner(),
[INFO] [stdout] 7630 | |                                 rhs.into_inner(),
[INFO] [stdout] 7631 | |                             )
[INFO] [stdout] 7632 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7631 -                             )
[INFO] [stdout] 7632 -                             .into();
[INFO] [stdout] 7631 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7628 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::manhattan_distance(
[INFO] [stdout] 7629 |                                 _self.into_inner(),
[INFO] [stdout] 7630 |                                 rhs.into_inner(),
[INFO] [stdout] 7631 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7530:43
[INFO] [stdout]      |
[INFO] [stdout] 7530 |                           let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7531 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7664:43
[INFO] [stdout]      |
[INFO] [stdout] 7664 |                           let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7665 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:7545:44
[INFO] [stdout]      |
[INFO] [stdout] 7545 |                           let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 7546 | |                             ::glam::IVec4,
[INFO] [stdout] 7547 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7547 -                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 -                             .into();
[INFO] [stdout] 7547 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7545 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 7546 |                             ::glam::IVec4,
[INFO] [stdout] 7547 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7679:45
[INFO] [stdout]      |
[INFO] [stdout] 7679 |                           let output: usize = ::glam::IVec4::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7680 | |                                 _self.into_inner(),
[INFO] [stdout] 7681 | |                             )
[INFO] [stdout] 7682 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7681 -                             )
[INFO] [stdout] 7682 -                             .into();
[INFO] [stdout] 7681 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7679 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::max_position(
[INFO] [stdout] 7680 |                                 _self.into_inner(),
[INFO] [stdout] 7681 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7577:43
[INFO] [stdout]      |
[INFO] [stdout] 7577 |                           let output: u32 = ::glam::IVec4::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7578 | |                                 _self.into_inner(),
[INFO] [stdout] 7579 | |                             )
[INFO] [stdout] 7580 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7579 -                             )
[INFO] [stdout] 7580 -                             .into();
[INFO] [stdout] 7579 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7577 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::is_negative_bitmask(
[INFO] [stdout] 7578 |                                 _self.into_inner(),
[INFO] [stdout] 7579 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7714:43
[INFO] [stdout]      |
[INFO] [stdout] 7714 |                           let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7715 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7611:43
[INFO] [stdout]      |
[INFO] [stdout] 7611 |                           let output: i32 = ::glam::IVec4::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7612 | |                                 _self.into_inner(),
[INFO] [stdout] 7613 | |                             )
[INFO] [stdout] 7614 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7613 -                             )
[INFO] [stdout] 7614 -                             .into();
[INFO] [stdout] 7613 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7611 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::length_squared(
[INFO] [stdout] 7612 |                                 _self.into_inner(),
[INFO] [stdout] 7613 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7729:45
[INFO] [stdout]      |
[INFO] [stdout] 7729 |                           let output: usize = ::glam::IVec4::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7730 | |                                 _self.into_inner(),
[INFO] [stdout] 7731 | |                             )
[INFO] [stdout] 7732 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7731 -                             )
[INFO] [stdout] 7732 -                             .into();
[INFO] [stdout] 7731 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7729 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::min_position(
[INFO] [stdout] 7730 |                                 _self.into_inner(),
[INFO] [stdout] 7731 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7628:43
[INFO] [stdout]      |
[INFO] [stdout] 7628 |                           let output: u32 = ::glam::IVec4::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7629 | |                                 _self.into_inner(),
[INFO] [stdout] 7630 | |                                 rhs.into_inner(),
[INFO] [stdout] 7631 | |                             )
[INFO] [stdout] 7632 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7631 -                             )
[INFO] [stdout] 7632 -                             .into();
[INFO] [stdout] 7631 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7628 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::manhattan_distance(
[INFO] [stdout] 7629 |                                 _self.into_inner(),
[INFO] [stdout] 7630 |                                 rhs.into_inner(),
[INFO] [stdout] 7631 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 4]`
[INFO] [stdout]     --> src/lib.rs:8111:48
[INFO] [stdout]      |
[INFO] [stdout] 8111 |                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = <[i32; 4] as Into<_>>::into(::glam::IVec4::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7664:43
[INFO] [stdout]      |
[INFO] [stdout] 7664 |                           let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7665 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8551:42
[INFO] [stdout]      |
[INFO] [stdout] 8551 |                           let output: u8 = ::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8552 | |                                 _self.into_inner(),
[INFO] [stdout] 8553 | |                                 rhs.into_inner(),
[INFO] [stdout] 8554 | |                             )
[INFO] [stdout] 8555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8554 -                             )
[INFO] [stdout] 8555 -                             .into();
[INFO] [stdout] 8554 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8551 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout] 8552 |                                 _self.into_inner(),
[INFO] [stdout] 8553 |                                 rhs.into_inner(),
[INFO] [stdout] 8554 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7679:45
[INFO] [stdout]      |
[INFO] [stdout] 7679 |                           let output: usize = ::glam::IVec4::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7680 | |                                 _self.into_inner(),
[INFO] [stdout] 7681 | |                             )
[INFO] [stdout] 7682 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7681 -                             )
[INFO] [stdout] 7682 -                             .into();
[INFO] [stdout] 7681 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7679 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::max_position(
[INFO] [stdout] 7680 |                                 _self.into_inner(),
[INFO] [stdout] 7681 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:8569:66
[INFO] [stdout]      |
[INFO] [stdout] 8569 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 8570 | |                                 _self.into_inner(),
[INFO] [stdout] 8571 | |                                 rhs.into_inner(),
[INFO] [stdout] 8572 | |                             )
[INFO] [stdout] 8573 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8572 -                             )
[INFO] [stdout] 8573 -                             .into();
[INFO] [stdout] 8572 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8569 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout] 8570 |                                 _self.into_inner(),
[INFO] [stdout] 8571 |                                 rhs.into_inner(),
[INFO] [stdout] 8572 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7714:43
[INFO] [stdout]      |
[INFO] [stdout] 7714 |                           let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7715 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8731:42
[INFO] [stdout]      |
[INFO] [stdout] 8731 |                           let output: i8 = ::glam::I8Vec2::distance_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8732 | |                                 _self.into_inner(),
[INFO] [stdout] 8733 | |                                 rhs.into_inner(),
[INFO] [stdout] 8734 | |                             )
[INFO] [stdout] 8735 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8734 -                             )
[INFO] [stdout] 8735 -                             .into();
[INFO] [stdout] 8734 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8731 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::distance_squared(
[INFO] [stdout] 8732 |                                 _self.into_inner(),
[INFO] [stdout] 8733 |                                 rhs.into_inner(),
[INFO] [stdout] 8734 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8818:42
[INFO] [stdout]      |
[INFO] [stdout] 8818 |                           let output: i8 = ::glam::I8Vec2::dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8819 | |                                 _self.into_inner(),
[INFO] [stdout] 8820 | |                                 rhs.into_inner(),
[INFO] [stdout] 8821 | |                             )
[INFO] [stdout] 8822 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8821 -                             )
[INFO] [stdout] 8822 -                             .into();
[INFO] [stdout] 8821 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8818 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::dot(
[INFO] [stdout] 8819 |                                 _self.into_inner(),
[INFO] [stdout] 8820 |                                 rhs.into_inner(),
[INFO] [stdout] 8821 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8854:42
[INFO] [stdout]      |
[INFO] [stdout] 8854 |                           let output: i8 = ::glam::I8Vec2::element_product(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8855 | |                                 _self.into_inner(),
[INFO] [stdout] 8856 | |                             )
[INFO] [stdout] 8857 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8856 -                             )
[INFO] [stdout] 8857 -                             .into();
[INFO] [stdout] 8856 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8854 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_product(
[INFO] [stdout] 8855 |                                 _self.into_inner(),
[INFO] [stdout] 8856 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8871:42
[INFO] [stdout]      |
[INFO] [stdout] 8871 |                           let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8872 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7729:45
[INFO] [stdout]      |
[INFO] [stdout] 7729 |                           let output: usize = ::glam::IVec4::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7730 | |                                 _self.into_inner(),
[INFO] [stdout] 7731 | |                             )
[INFO] [stdout] 7732 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7731 -                             )
[INFO] [stdout] 7732 -                             .into();
[INFO] [stdout] 7731 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7729 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::min_position(
[INFO] [stdout] 7730 |                                 _self.into_inner(),
[INFO] [stdout] 7731 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 4]`
[INFO] [stdout]     --> src/lib.rs:8111:48
[INFO] [stdout]      |
[INFO] [stdout] 8111 |                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = <[i32; 4] as Into<_>>::into(::glam::IVec4::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8551:42
[INFO] [stdout]      |
[INFO] [stdout] 8551 |                           let output: u8 = ::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8552 | |                                 _self.into_inner(),
[INFO] [stdout] 8553 | |                                 rhs.into_inner(),
[INFO] [stdout] 8554 | |                             )
[INFO] [stdout] 8555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8554 -                             )
[INFO] [stdout] 8555 -                             .into();
[INFO] [stdout] 8554 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8551 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout] 8552 |                                 _self.into_inner(),
[INFO] [stdout] 8553 |                                 rhs.into_inner(),
[INFO] [stdout] 8554 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:8886:44
[INFO] [stdout]      |
[INFO] [stdout] 8886 |                           let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 8887 | |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8888 -                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 -                             .into();
[INFO] [stdout] 8888 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8886 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 8887 |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:8569:66
[INFO] [stdout]      |
[INFO] [stdout] 8569 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 8570 | |                                 _self.into_inner(),
[INFO] [stdout] 8571 | |                                 rhs.into_inner(),
[INFO] [stdout] 8572 | |                             )
[INFO] [stdout] 8573 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8572 -                             )
[INFO] [stdout] 8573 -                             .into();
[INFO] [stdout] 8572 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8569 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout] 8570 |                                 _self.into_inner(),
[INFO] [stdout] 8571 |                                 rhs.into_inner(),
[INFO] [stdout] 8572 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:8936:43
[INFO] [stdout]      |
[INFO] [stdout] 8936 |                           let output: u32 = ::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 8937 | |                                 _self.into_inner(),
[INFO] [stdout] 8938 | |                             )
[INFO] [stdout] 8939 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8938 -                             )
[INFO] [stdout] 8939 -                             .into();
[INFO] [stdout] 8938 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8936 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout] 8937 |                                 _self.into_inner(),
[INFO] [stdout] 8938 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8731:42
[INFO] [stdout]      |
[INFO] [stdout] 8731 |                           let output: i8 = ::glam::I8Vec2::distance_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8732 | |                                 _self.into_inner(),
[INFO] [stdout] 8733 | |                                 rhs.into_inner(),
[INFO] [stdout] 8734 | |                             )
[INFO] [stdout] 8735 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8734 -                             )
[INFO] [stdout] 8735 -                             .into();
[INFO] [stdout] 8734 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8731 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::distance_squared(
[INFO] [stdout] 8732 |                                 _self.into_inner(),
[INFO] [stdout] 8733 |                                 rhs.into_inner(),
[INFO] [stdout] 8734 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8970:42
[INFO] [stdout]      |
[INFO] [stdout] 8970 |                           let output: i8 = ::glam::I8Vec2::length_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8971 | |                                 _self.into_inner(),
[INFO] [stdout] 8972 | |                             )
[INFO] [stdout] 8973 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8972 -                             )
[INFO] [stdout] 8973 -                             .into();
[INFO] [stdout] 8972 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8970 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::length_squared(
[INFO] [stdout] 8971 |                                 _self.into_inner(),
[INFO] [stdout] 8972 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8818:42
[INFO] [stdout]      |
[INFO] [stdout] 8818 |                           let output: i8 = ::glam::I8Vec2::dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8819 | |                                 _self.into_inner(),
[INFO] [stdout] 8820 | |                                 rhs.into_inner(),
[INFO] [stdout] 8821 | |                             )
[INFO] [stdout] 8822 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8821 -                             )
[INFO] [stdout] 8822 -                             .into();
[INFO] [stdout] 8821 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8818 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::dot(
[INFO] [stdout] 8819 |                                 _self.into_inner(),
[INFO] [stdout] 8820 |                                 rhs.into_inner(),
[INFO] [stdout] 8821 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8987:42
[INFO] [stdout]      |
[INFO] [stdout] 8987 |                           let output: u8 = ::glam::I8Vec2::manhattan_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8988 | |                                 _self.into_inner(),
[INFO] [stdout] 8989 | |                                 rhs.into_inner(),
[INFO] [stdout] 8990 | |                             )
[INFO] [stdout] 8991 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8990 -                             )
[INFO] [stdout] 8991 -                             .into();
[INFO] [stdout] 8990 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8987 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::manhattan_distance(
[INFO] [stdout] 8988 |                                 _self.into_inner(),
[INFO] [stdout] 8989 |                                 rhs.into_inner(),
[INFO] [stdout] 8990 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8854:42
[INFO] [stdout]      |
[INFO] [stdout] 8854 |                           let output: i8 = ::glam::I8Vec2::element_product(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8855 | |                                 _self.into_inner(),
[INFO] [stdout] 8856 | |                             )
[INFO] [stdout] 8857 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8856 -                             )
[INFO] [stdout] 8857 -                             .into();
[INFO] [stdout] 8856 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8854 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_product(
[INFO] [stdout] 8855 |                                 _self.into_inner(),
[INFO] [stdout] 8856 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9023:42
[INFO] [stdout]      |
[INFO] [stdout] 9023 |                           let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9024 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8871:42
[INFO] [stdout]      |
[INFO] [stdout] 8871 |                           let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8872 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9038:45
[INFO] [stdout]      |
[INFO] [stdout] 9038 |                           let output: usize = ::glam::I8Vec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9039 | |                                 _self.into_inner(),
[INFO] [stdout] 9040 | |                             )
[INFO] [stdout] 9041 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9040 -                             )
[INFO] [stdout] 9041 -                             .into();
[INFO] [stdout] 9040 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9038 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::max_position(
[INFO] [stdout] 9039 |                                 _self.into_inner(),
[INFO] [stdout] 9040 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9073:42
[INFO] [stdout]      |
[INFO] [stdout] 9073 |                           let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9074 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9088:45
[INFO] [stdout]      |
[INFO] [stdout] 9088 |                           let output: usize = ::glam::I8Vec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9089 | |                                 _self.into_inner(),
[INFO] [stdout] 9090 | |                             )
[INFO] [stdout] 9091 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9090 -                             )
[INFO] [stdout] 9091 -                             .into();
[INFO] [stdout] 9090 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9088 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::min_position(
[INFO] [stdout] 9089 |                                 _self.into_inner(),
[INFO] [stdout] 9090 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9204:42
[INFO] [stdout]      |
[INFO] [stdout] 9204 |                           let output: i8 = ::glam::I8Vec2::perp_dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9205 | |                                 _self.into_inner(),
[INFO] [stdout] 9206 | |                                 rhs.into_inner(),
[INFO] [stdout] 9207 | |                             )
[INFO] [stdout] 9208 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9207 -                             )
[INFO] [stdout] 9208 -                             .into();
[INFO] [stdout] 9207 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9204 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::perp_dot(
[INFO] [stdout] 9205 |                                 _self.into_inner(),
[INFO] [stdout] 9206 |                                 rhs.into_inner(),
[INFO] [stdout] 9207 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:8886:44
[INFO] [stdout]      |
[INFO] [stdout] 8886 |                           let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 8887 | |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8888 -                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 -                             .into();
[INFO] [stdout] 8888 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8886 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 8887 |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:8936:43
[INFO] [stdout]      |
[INFO] [stdout] 8936 |                           let output: u32 = ::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 8937 | |                                 _self.into_inner(),
[INFO] [stdout] 8938 | |                             )
[INFO] [stdout] 8939 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8938 -                             )
[INFO] [stdout] 8939 -                             .into();
[INFO] [stdout] 8938 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8936 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout] 8937 |                                 _self.into_inner(),
[INFO] [stdout] 8938 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 2]`
[INFO] [stdout]     --> src/lib.rs:9522:47
[INFO] [stdout]      |
[INFO] [stdout] 9522 |                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = <[i8; 2] as Into<_>>::into(::glam::I8Vec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8970:42
[INFO] [stdout]      |
[INFO] [stdout] 8970 |                           let output: i8 = ::glam::I8Vec2::length_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8971 | |                                 _self.into_inner(),
[INFO] [stdout] 8972 | |                             )
[INFO] [stdout] 8973 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8972 -                             )
[INFO] [stdout] 8973 -                             .into();
[INFO] [stdout] 8972 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8970 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::length_squared(
[INFO] [stdout] 8971 |                                 _self.into_inner(),
[INFO] [stdout] 8972 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8987:42
[INFO] [stdout]      |
[INFO] [stdout] 8987 |                           let output: u8 = ::glam::I8Vec2::manhattan_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8988 | |                                 _self.into_inner(),
[INFO] [stdout] 8989 | |                                 rhs.into_inner(),
[INFO] [stdout] 8990 | |                             )
[INFO] [stdout] 8991 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8990 -                             )
[INFO] [stdout] 8991 -                             .into();
[INFO] [stdout] 8990 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8987 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::manhattan_distance(
[INFO] [stdout] 8988 |                                 _self.into_inner(),
[INFO] [stdout] 8989 |                                 rhs.into_inner(),
[INFO] [stdout] 8990 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9023:42
[INFO] [stdout]      |
[INFO] [stdout] 9023 |                           let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9024 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:9926:42
[INFO] [stdout]      |
[INFO] [stdout] 9926 |                           let output: u8 = ::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9927 | |                                 _self.into_inner(),
[INFO] [stdout] 9928 | |                                 rhs.into_inner(),
[INFO] [stdout] 9929 | |                             )
[INFO] [stdout] 9930 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9929 -                             )
[INFO] [stdout] 9930 -                             .into();
[INFO] [stdout] 9929 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9926 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout] 9927 |                                 _self.into_inner(),
[INFO] [stdout] 9928 |                                 rhs.into_inner(),
[INFO] [stdout] 9929 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9038:45
[INFO] [stdout]      |
[INFO] [stdout] 9038 |                           let output: usize = ::glam::I8Vec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9039 | |                                 _self.into_inner(),
[INFO] [stdout] 9040 | |                             )
[INFO] [stdout] 9041 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9040 -                             )
[INFO] [stdout] 9041 -                             .into();
[INFO] [stdout] 9040 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9038 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::max_position(
[INFO] [stdout] 9039 |                                 _self.into_inner(),
[INFO] [stdout] 9040 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9073:42
[INFO] [stdout]      |
[INFO] [stdout] 9073 |                           let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9074 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:9944:66
[INFO] [stdout]      |
[INFO] [stdout] 9944 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 9945 | |                                 _self.into_inner(),
[INFO] [stdout] 9946 | |                                 rhs.into_inner(),
[INFO] [stdout] 9947 | |                             )
[INFO] [stdout] 9948 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9947 -                             )
[INFO] [stdout] 9948 -                             .into();
[INFO] [stdout] 9947 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9944 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout] 9945 |                                 _self.into_inner(),
[INFO] [stdout] 9946 |                                 rhs.into_inner(),
[INFO] [stdout] 9947 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9088:45
[INFO] [stdout]      |
[INFO] [stdout] 9088 |                           let output: usize = ::glam::I8Vec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9089 | |                                 _self.into_inner(),
[INFO] [stdout] 9090 | |                             )
[INFO] [stdout] 9091 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9090 -                             )
[INFO] [stdout] 9091 -                             .into();
[INFO] [stdout] 9090 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9088 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::min_position(
[INFO] [stdout] 9089 |                                 _self.into_inner(),
[INFO] [stdout] 9090 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10124:42
[INFO] [stdout]       |
[INFO] [stdout] 10124 |                           let output: i8 = ::glam::I8Vec3::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10125 | |                                 _self.into_inner(),
[INFO] [stdout] 10126 | |                                 rhs.into_inner(),
[INFO] [stdout] 10127 | |                             )
[INFO] [stdout] 10128 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10127 -                             )
[INFO] [stdout] 10128 -                             .into();
[INFO] [stdout] 10127 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10124 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::distance_squared(
[INFO] [stdout] 10125 |                                 _self.into_inner(),
[INFO] [stdout] 10126 |                                 rhs.into_inner(),
[INFO] [stdout] 10127 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9204:42
[INFO] [stdout]      |
[INFO] [stdout] 9204 |                           let output: i8 = ::glam::I8Vec2::perp_dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9205 | |                                 _self.into_inner(),
[INFO] [stdout] 9206 | |                                 rhs.into_inner(),
[INFO] [stdout] 9207 | |                             )
[INFO] [stdout] 9208 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9207 -                             )
[INFO] [stdout] 9208 -                             .into();
[INFO] [stdout] 9207 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9204 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::perp_dot(
[INFO] [stdout] 9205 |                                 _self.into_inner(),
[INFO] [stdout] 9206 |                                 rhs.into_inner(),
[INFO] [stdout] 9207 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10211:42
[INFO] [stdout]       |
[INFO] [stdout] 10211 |                           let output: i8 = ::glam::I8Vec3::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10212 | |                                 _self.into_inner(),
[INFO] [stdout] 10213 | |                                 rhs.into_inner(),
[INFO] [stdout] 10214 | |                             )
[INFO] [stdout] 10215 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10214 -                             )
[INFO] [stdout] 10215 -                             .into();
[INFO] [stdout] 10214 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10211 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::dot(
[INFO] [stdout] 10212 |                                 _self.into_inner(),
[INFO] [stdout] 10213 |                                 rhs.into_inner(),
[INFO] [stdout] 10214 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10247:42
[INFO] [stdout]       |
[INFO] [stdout] 10247 |                           let output: i8 = ::glam::I8Vec3::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10248 | |                                 _self.into_inner(),
[INFO] [stdout] 10249 | |                             )
[INFO] [stdout] 10250 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10249 -                             )
[INFO] [stdout] 10250 -                             .into();
[INFO] [stdout] 10249 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10247 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_product(
[INFO] [stdout] 10248 |                                 _self.into_inner(),
[INFO] [stdout] 10249 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10264:42
[INFO] [stdout]       |
[INFO] [stdout] 10264 |                           let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10265 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:10279:44
[INFO] [stdout]       |
[INFO] [stdout] 10279 |                           let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 10280 | |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10281 -                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 -                             .into();
[INFO] [stdout] 10281 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10279 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 10280 |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 2]`
[INFO] [stdout]     --> src/lib.rs:9522:47
[INFO] [stdout]      |
[INFO] [stdout] 9522 |                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = <[i8; 2] as Into<_>>::into(::glam::I8Vec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:9926:42
[INFO] [stdout]      |
[INFO] [stdout] 9926 |                           let output: u8 = ::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9927 | |                                 _self.into_inner(),
[INFO] [stdout] 9928 | |                                 rhs.into_inner(),
[INFO] [stdout] 9929 | |                             )
[INFO] [stdout] 9930 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9929 -                             )
[INFO] [stdout] 9930 -                             .into();
[INFO] [stdout] 9929 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9926 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout] 9927 |                                 _self.into_inner(),
[INFO] [stdout] 9928 |                                 rhs.into_inner(),
[INFO] [stdout] 9929 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:10329:43
[INFO] [stdout]       |
[INFO] [stdout] 10329 |                           let output: u32 = ::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 10330 | |                                 _self.into_inner(),
[INFO] [stdout] 10331 | |                             )
[INFO] [stdout] 10332 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10331 -                             )
[INFO] [stdout] 10332 -                             .into();
[INFO] [stdout] 10331 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10329 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout] 10330 |                                 _self.into_inner(),
[INFO] [stdout] 10331 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:9944:66
[INFO] [stdout]      |
[INFO] [stdout] 9944 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 9945 | |                                 _self.into_inner(),
[INFO] [stdout] 9946 | |                                 rhs.into_inner(),
[INFO] [stdout] 9947 | |                             )
[INFO] [stdout] 9948 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9947 -                             )
[INFO] [stdout] 9948 -                             .into();
[INFO] [stdout] 9947 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9944 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout] 9945 |                                 _self.into_inner(),
[INFO] [stdout] 9946 |                                 rhs.into_inner(),
[INFO] [stdout] 9947 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10124:42
[INFO] [stdout]       |
[INFO] [stdout] 10124 |                           let output: i8 = ::glam::I8Vec3::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10125 | |                                 _self.into_inner(),
[INFO] [stdout] 10126 | |                                 rhs.into_inner(),
[INFO] [stdout] 10127 | |                             )
[INFO] [stdout] 10128 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10127 -                             )
[INFO] [stdout] 10128 -                             .into();
[INFO] [stdout] 10127 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10124 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::distance_squared(
[INFO] [stdout] 10125 |                                 _self.into_inner(),
[INFO] [stdout] 10126 |                                 rhs.into_inner(),
[INFO] [stdout] 10127 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10363:42
[INFO] [stdout]       |
[INFO] [stdout] 10363 |                           let output: i8 = ::glam::I8Vec3::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10364 | |                                 _self.into_inner(),
[INFO] [stdout] 10365 | |                             )
[INFO] [stdout] 10366 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10365 -                             )
[INFO] [stdout] 10366 -                             .into();
[INFO] [stdout] 10365 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10363 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::length_squared(
[INFO] [stdout] 10364 |                                 _self.into_inner(),
[INFO] [stdout] 10365 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10211:42
[INFO] [stdout]       |
[INFO] [stdout] 10211 |                           let output: i8 = ::glam::I8Vec3::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10212 | |                                 _self.into_inner(),
[INFO] [stdout] 10213 | |                                 rhs.into_inner(),
[INFO] [stdout] 10214 | |                             )
[INFO] [stdout] 10215 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10214 -                             )
[INFO] [stdout] 10215 -                             .into();
[INFO] [stdout] 10214 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10211 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::dot(
[INFO] [stdout] 10212 |                                 _self.into_inner(),
[INFO] [stdout] 10213 |                                 rhs.into_inner(),
[INFO] [stdout] 10214 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:10380:42
[INFO] [stdout]       |
[INFO] [stdout] 10380 |                           let output: u8 = ::glam::I8Vec3::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10381 | |                                 _self.into_inner(),
[INFO] [stdout] 10382 | |                                 rhs.into_inner(),
[INFO] [stdout] 10383 | |                             )
[INFO] [stdout] 10384 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10383 -                             )
[INFO] [stdout] 10384 -                             .into();
[INFO] [stdout] 10383 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10380 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::manhattan_distance(
[INFO] [stdout] 10381 |                                 _self.into_inner(),
[INFO] [stdout] 10382 |                                 rhs.into_inner(),
[INFO] [stdout] 10383 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10247:42
[INFO] [stdout]       |
[INFO] [stdout] 10247 |                           let output: i8 = ::glam::I8Vec3::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10248 | |                                 _self.into_inner(),
[INFO] [stdout] 10249 | |                             )
[INFO] [stdout] 10250 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10249 -                             )
[INFO] [stdout] 10250 -                             .into();
[INFO] [stdout] 10249 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10247 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_product(
[INFO] [stdout] 10248 |                                 _self.into_inner(),
[INFO] [stdout] 10249 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10416:42
[INFO] [stdout]       |
[INFO] [stdout] 10416 |                           let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10417 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10264:42
[INFO] [stdout]       |
[INFO] [stdout] 10264 |                           let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10265 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10431:45
[INFO] [stdout]       |
[INFO] [stdout] 10431 |                           let output: usize = ::glam::I8Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10432 | |                                 _self.into_inner(),
[INFO] [stdout] 10433 | |                             )
[INFO] [stdout] 10434 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10433 -                             )
[INFO] [stdout] 10434 -                             .into();
[INFO] [stdout] 10433 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10431 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::max_position(
[INFO] [stdout] 10432 |                                 _self.into_inner(),
[INFO] [stdout] 10433 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:10279:44
[INFO] [stdout]       |
[INFO] [stdout] 10279 |                           let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 10280 | |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10281 -                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 -                             .into();
[INFO] [stdout] 10281 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10279 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 10280 |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10466:42
[INFO] [stdout]       |
[INFO] [stdout] 10466 |                           let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10467 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:10329:43
[INFO] [stdout]       |
[INFO] [stdout] 10329 |                           let output: u32 = ::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 10330 | |                                 _self.into_inner(),
[INFO] [stdout] 10331 | |                             )
[INFO] [stdout] 10332 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10331 -                             )
[INFO] [stdout] 10332 -                             .into();
[INFO] [stdout] 10331 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10329 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout] 10330 |                                 _self.into_inner(),
[INFO] [stdout] 10331 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10481:45
[INFO] [stdout]       |
[INFO] [stdout] 10481 |                           let output: usize = ::glam::I8Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10482 | |                                 _self.into_inner(),
[INFO] [stdout] 10483 | |                             )
[INFO] [stdout] 10484 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10483 -                             )
[INFO] [stdout] 10484 -                             .into();
[INFO] [stdout] 10483 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10481 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::min_position(
[INFO] [stdout] 10482 |                                 _self.into_inner(),
[INFO] [stdout] 10483 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10363:42
[INFO] [stdout]       |
[INFO] [stdout] 10363 |                           let output: i8 = ::glam::I8Vec3::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10364 | |                                 _self.into_inner(),
[INFO] [stdout] 10365 | |                             )
[INFO] [stdout] 10366 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10365 -                             )
[INFO] [stdout] 10366 -                             .into();
[INFO] [stdout] 10365 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10363 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::length_squared(
[INFO] [stdout] 10364 |                                 _self.into_inner(),
[INFO] [stdout] 10365 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 3]`
[INFO] [stdout]      --> src/lib.rs:10863:47
[INFO] [stdout]       |
[INFO] [stdout] 10863 |                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = <[i8; 3] as Into<_>>::into(::glam::I8Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:10380:42
[INFO] [stdout]       |
[INFO] [stdout] 10380 |                           let output: u8 = ::glam::I8Vec3::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10381 | |                                 _self.into_inner(),
[INFO] [stdout] 10382 | |                                 rhs.into_inner(),
[INFO] [stdout] 10383 | |                             )
[INFO] [stdout] 10384 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10383 -                             )
[INFO] [stdout] 10384 -                             .into();
[INFO] [stdout] 10383 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10380 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::manhattan_distance(
[INFO] [stdout] 10381 |                                 _self.into_inner(),
[INFO] [stdout] 10382 |                                 rhs.into_inner(),
[INFO] [stdout] 10383 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10416:42
[INFO] [stdout]       |
[INFO] [stdout] 10416 |                           let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10417 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11285:42
[INFO] [stdout]       |
[INFO] [stdout] 11285 |                           let output: u8 = ::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11286 | |                                 _self.into_inner(),
[INFO] [stdout] 11287 | |                                 rhs.into_inner(),
[INFO] [stdout] 11288 | |                             )
[INFO] [stdout] 11289 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11288 -                             )
[INFO] [stdout] 11289 -                             .into();
[INFO] [stdout] 11288 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11285 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout] 11286 |                                 _self.into_inner(),
[INFO] [stdout] 11287 |                                 rhs.into_inner(),
[INFO] [stdout] 11288 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10431:45
[INFO] [stdout]       |
[INFO] [stdout] 10431 |                           let output: usize = ::glam::I8Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10432 | |                                 _self.into_inner(),
[INFO] [stdout] 10433 | |                             )
[INFO] [stdout] 10434 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10433 -                             )
[INFO] [stdout] 10434 -                             .into();
[INFO] [stdout] 10433 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10431 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::max_position(
[INFO] [stdout] 10432 |                                 _self.into_inner(),
[INFO] [stdout] 10433 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:11303:66
[INFO] [stdout]       |
[INFO] [stdout] 11303 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 11304 | |                                 _self.into_inner(),
[INFO] [stdout] 11305 | |                                 rhs.into_inner(),
[INFO] [stdout] 11306 | |                             )
[INFO] [stdout] 11307 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11306 -                             )
[INFO] [stdout] 11307 -                             .into();
[INFO] [stdout] 11306 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11303 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout] 11304 |                                 _self.into_inner(),
[INFO] [stdout] 11305 |                                 rhs.into_inner(),
[INFO] [stdout] 11306 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10466:42
[INFO] [stdout]       |
[INFO] [stdout] 10466 |                           let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10467 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11465:42
[INFO] [stdout]       |
[INFO] [stdout] 11465 |                           let output: i8 = ::glam::I8Vec4::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11466 | |                                 _self.into_inner(),
[INFO] [stdout] 11467 | |                                 rhs.into_inner(),
[INFO] [stdout] 11468 | |                             )
[INFO] [stdout] 11469 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11468 -                             )
[INFO] [stdout] 11469 -                             .into();
[INFO] [stdout] 11468 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11465 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::distance_squared(
[INFO] [stdout] 11466 |                                 _self.into_inner(),
[INFO] [stdout] 11467 |                                 rhs.into_inner(),
[INFO] [stdout] 11468 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10481:45
[INFO] [stdout]       |
[INFO] [stdout] 10481 |                           let output: usize = ::glam::I8Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10482 | |                                 _self.into_inner(),
[INFO] [stdout] 10483 | |                             )
[INFO] [stdout] 10484 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10483 -                             )
[INFO] [stdout] 10484 -                             .into();
[INFO] [stdout] 10483 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10481 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::min_position(
[INFO] [stdout] 10482 |                                 _self.into_inner(),
[INFO] [stdout] 10483 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11552:42
[INFO] [stdout]       |
[INFO] [stdout] 11552 |                           let output: i8 = ::glam::I8Vec4::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11553 | |                                 _self.into_inner(),
[INFO] [stdout] 11554 | |                                 rhs.into_inner(),
[INFO] [stdout] 11555 | |                             )
[INFO] [stdout] 11556 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11555 -                             )
[INFO] [stdout] 11556 -                             .into();
[INFO] [stdout] 11555 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11552 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::dot(
[INFO] [stdout] 11553 |                                 _self.into_inner(),
[INFO] [stdout] 11554 |                                 rhs.into_inner(),
[INFO] [stdout] 11555 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 3]`
[INFO] [stdout]      --> src/lib.rs:10863:47
[INFO] [stdout]       |
[INFO] [stdout] 10863 |                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = <[i8; 3] as Into<_>>::into(::glam::I8Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11588:42
[INFO] [stdout]       |
[INFO] [stdout] 11588 |                           let output: i8 = ::glam::I8Vec4::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11589 | |                                 _self.into_inner(),
[INFO] [stdout] 11590 | |                             )
[INFO] [stdout] 11591 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11590 -                             )
[INFO] [stdout] 11591 -                             .into();
[INFO] [stdout] 11590 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11588 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_product(
[INFO] [stdout] 11589 |                                 _self.into_inner(),
[INFO] [stdout] 11590 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11285:42
[INFO] [stdout]       |
[INFO] [stdout] 11285 |                           let output: u8 = ::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11286 | |                                 _self.into_inner(),
[INFO] [stdout] 11287 | |                                 rhs.into_inner(),
[INFO] [stdout] 11288 | |                             )
[INFO] [stdout] 11289 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11288 -                             )
[INFO] [stdout] 11289 -                             .into();
[INFO] [stdout] 11288 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11285 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout] 11286 |                                 _self.into_inner(),
[INFO] [stdout] 11287 |                                 rhs.into_inner(),
[INFO] [stdout] 11288 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11605:42
[INFO] [stdout]       |
[INFO] [stdout] 11605 |                           let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11606 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:11303:66
[INFO] [stdout]       |
[INFO] [stdout] 11303 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 11304 | |                                 _self.into_inner(),
[INFO] [stdout] 11305 | |                                 rhs.into_inner(),
[INFO] [stdout] 11306 | |                             )
[INFO] [stdout] 11307 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11306 -                             )
[INFO] [stdout] 11307 -                             .into();
[INFO] [stdout] 11306 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11303 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout] 11304 |                                 _self.into_inner(),
[INFO] [stdout] 11305 |                                 rhs.into_inner(),
[INFO] [stdout] 11306 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:11620:44
[INFO] [stdout]       |
[INFO] [stdout] 11620 |                           let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 11621 | |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11622 -                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 -                             .into();
[INFO] [stdout] 11622 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11620 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 11621 |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11465:42
[INFO] [stdout]       |
[INFO] [stdout] 11465 |                           let output: i8 = ::glam::I8Vec4::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11466 | |                                 _self.into_inner(),
[INFO] [stdout] 11467 | |                                 rhs.into_inner(),
[INFO] [stdout] 11468 | |                             )
[INFO] [stdout] 11469 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11468 -                             )
[INFO] [stdout] 11469 -                             .into();
[INFO] [stdout] 11468 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11465 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::distance_squared(
[INFO] [stdout] 11466 |                                 _self.into_inner(),
[INFO] [stdout] 11467 |                                 rhs.into_inner(),
[INFO] [stdout] 11468 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:11652:43
[INFO] [stdout]       |
[INFO] [stdout] 11652 |                           let output: u32 = ::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 11653 | |                                 _self.into_inner(),
[INFO] [stdout] 11654 | |                             )
[INFO] [stdout] 11655 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11654 -                             )
[INFO] [stdout] 11655 -                             .into();
[INFO] [stdout] 11654 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11652 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout] 11653 |                                 _self.into_inner(),
[INFO] [stdout] 11654 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11552:42
[INFO] [stdout]       |
[INFO] [stdout] 11552 |                           let output: i8 = ::glam::I8Vec4::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11553 | |                                 _self.into_inner(),
[INFO] [stdout] 11554 | |                                 rhs.into_inner(),
[INFO] [stdout] 11555 | |                             )
[INFO] [stdout] 11556 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11555 -                             )
[INFO] [stdout] 11556 -                             .into();
[INFO] [stdout] 11555 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11552 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::dot(
[INFO] [stdout] 11553 |                                 _self.into_inner(),
[INFO] [stdout] 11554 |                                 rhs.into_inner(),
[INFO] [stdout] 11555 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11686:42
[INFO] [stdout]       |
[INFO] [stdout] 11686 |                           let output: i8 = ::glam::I8Vec4::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11687 | |                                 _self.into_inner(),
[INFO] [stdout] 11688 | |                             )
[INFO] [stdout] 11689 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11688 -                             )
[INFO] [stdout] 11689 -                             .into();
[INFO] [stdout] 11688 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11686 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::length_squared(
[INFO] [stdout] 11687 |                                 _self.into_inner(),
[INFO] [stdout] 11688 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11588:42
[INFO] [stdout]       |
[INFO] [stdout] 11588 |                           let output: i8 = ::glam::I8Vec4::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11589 | |                                 _self.into_inner(),
[INFO] [stdout] 11590 | |                             )
[INFO] [stdout] 11591 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11590 -                             )
[INFO] [stdout] 11591 -                             .into();
[INFO] [stdout] 11590 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11588 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_product(
[INFO] [stdout] 11589 |                                 _self.into_inner(),
[INFO] [stdout] 11590 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11703:42
[INFO] [stdout]       |
[INFO] [stdout] 11703 |                           let output: u8 = ::glam::I8Vec4::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11704 | |                                 _self.into_inner(),
[INFO] [stdout] 11705 | |                                 rhs.into_inner(),
[INFO] [stdout] 11706 | |                             )
[INFO] [stdout] 11707 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11706 -                             )
[INFO] [stdout] 11707 -                             .into();
[INFO] [stdout] 11706 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11703 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::manhattan_distance(
[INFO] [stdout] 11704 |                                 _self.into_inner(),
[INFO] [stdout] 11705 |                                 rhs.into_inner(),
[INFO] [stdout] 11706 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11605:42
[INFO] [stdout]       |
[INFO] [stdout] 11605 |                           let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11606 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11739:42
[INFO] [stdout]       |
[INFO] [stdout] 11739 |                           let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11740 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:11620:44
[INFO] [stdout]       |
[INFO] [stdout] 11620 |                           let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 11621 | |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11622 -                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 -                             .into();
[INFO] [stdout] 11622 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11620 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 11621 |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:11652:43
[INFO] [stdout]       |
[INFO] [stdout] 11652 |                           let output: u32 = ::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 11653 | |                                 _self.into_inner(),
[INFO] [stdout] 11654 | |                             )
[INFO] [stdout] 11655 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11654 -                             )
[INFO] [stdout] 11655 -                             .into();
[INFO] [stdout] 11654 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11652 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout] 11653 |                                 _self.into_inner(),
[INFO] [stdout] 11654 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11686:42
[INFO] [stdout]       |
[INFO] [stdout] 11686 |                           let output: i8 = ::glam::I8Vec4::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11687 | |                                 _self.into_inner(),
[INFO] [stdout] 11688 | |                             )
[INFO] [stdout] 11689 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11688 -                             )
[INFO] [stdout] 11689 -                             .into();
[INFO] [stdout] 11688 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11686 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::length_squared(
[INFO] [stdout] 11687 |                                 _self.into_inner(),
[INFO] [stdout] 11688 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11703:42
[INFO] [stdout]       |
[INFO] [stdout] 11703 |                           let output: u8 = ::glam::I8Vec4::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11704 | |                                 _self.into_inner(),
[INFO] [stdout] 11705 | |                                 rhs.into_inner(),
[INFO] [stdout] 11706 | |                             )
[INFO] [stdout] 11707 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11706 -                             )
[INFO] [stdout] 11707 -                             .into();
[INFO] [stdout] 11706 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11703 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::manhattan_distance(
[INFO] [stdout] 11704 |                                 _self.into_inner(),
[INFO] [stdout] 11705 |                                 rhs.into_inner(),
[INFO] [stdout] 11706 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11754:45
[INFO] [stdout]       |
[INFO] [stdout] 11754 |                           let output: usize = ::glam::I8Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11755 | |                                 _self.into_inner(),
[INFO] [stdout] 11756 | |                             )
[INFO] [stdout] 11757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11756 -                             )
[INFO] [stdout] 11757 -                             .into();
[INFO] [stdout] 11756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11754 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::max_position(
[INFO] [stdout] 11755 |                                 _self.into_inner(),
[INFO] [stdout] 11756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11739:42
[INFO] [stdout]       |
[INFO] [stdout] 11739 |                           let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11740 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11789:42
[INFO] [stdout]       |
[INFO] [stdout] 11789 |                           let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11790 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11754:45
[INFO] [stdout]       |
[INFO] [stdout] 11754 |                           let output: usize = ::glam::I8Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11755 | |                                 _self.into_inner(),
[INFO] [stdout] 11756 | |                             )
[INFO] [stdout] 11757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11756 -                             )
[INFO] [stdout] 11757 -                             .into();
[INFO] [stdout] 11756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11754 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::max_position(
[INFO] [stdout] 11755 |                                 _self.into_inner(),
[INFO] [stdout] 11756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11804:45
[INFO] [stdout]       |
[INFO] [stdout] 11804 |                           let output: usize = ::glam::I8Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11805 | |                                 _self.into_inner(),
[INFO] [stdout] 11806 | |                             )
[INFO] [stdout] 11807 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11806 -                             )
[INFO] [stdout] 11807 -                             .into();
[INFO] [stdout] 11806 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11804 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::min_position(
[INFO] [stdout] 11805 |                                 _self.into_inner(),
[INFO] [stdout] 11806 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11789:42
[INFO] [stdout]       |
[INFO] [stdout] 11789 |                           let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11790 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 4]`
[INFO] [stdout]      --> src/lib.rs:12186:47
[INFO] [stdout]       |
[INFO] [stdout] 12186 |                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = <[i8; 4] as Into<_>>::into(::glam::I8Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:12626:43
[INFO] [stdout]       |
[INFO] [stdout] 12626 |                           let output: u16 = ::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12627 | |                                 _self.into_inner(),
[INFO] [stdout] 12628 | |                                 rhs.into_inner(),
[INFO] [stdout] 12629 | |                             )
[INFO] [stdout] 12630 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12629 -                             )
[INFO] [stdout] 12630 -                             .into();
[INFO] [stdout] 12629 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12626 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout] 12627 |                                 _self.into_inner(),
[INFO] [stdout] 12628 |                                 rhs.into_inner(),
[INFO] [stdout] 12629 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:12644:67
[INFO] [stdout]       |
[INFO] [stdout] 12644 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 12645 | |                                 _self.into_inner(),
[INFO] [stdout] 12646 | |                                 rhs.into_inner(),
[INFO] [stdout] 12647 | |                             )
[INFO] [stdout] 12648 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12647 -                             )
[INFO] [stdout] 12648 -                             .into();
[INFO] [stdout] 12647 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12644 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout] 12645 |                                 _self.into_inner(),
[INFO] [stdout] 12646 |                                 rhs.into_inner(),
[INFO] [stdout] 12647 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12810:43
[INFO] [stdout]       |
[INFO] [stdout] 12810 |                           let output: i16 = ::glam::I16Vec2::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12811 | |                                 _self.into_inner(),
[INFO] [stdout] 12812 | |                                 rhs.into_inner(),
[INFO] [stdout] 12813 | |                             )
[INFO] [stdout] 12814 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12813 -                             )
[INFO] [stdout] 12814 -                             .into();
[INFO] [stdout] 12813 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12810 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::distance_squared(
[INFO] [stdout] 12811 |                                 _self.into_inner(),
[INFO] [stdout] 12812 |                                 rhs.into_inner(),
[INFO] [stdout] 12813 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12897:43
[INFO] [stdout]       |
[INFO] [stdout] 12897 |                           let output: i16 = ::glam::I16Vec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12898 | |                                 _self.into_inner(),
[INFO] [stdout] 12899 | |                                 rhs.into_inner(),
[INFO] [stdout] 12900 | |                             )
[INFO] [stdout] 12901 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12900 -                             )
[INFO] [stdout] 12901 -                             .into();
[INFO] [stdout] 12900 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12897 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::dot(
[INFO] [stdout] 12898 |                                 _self.into_inner(),
[INFO] [stdout] 12899 |                                 rhs.into_inner(),
[INFO] [stdout] 12900 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12933:43
[INFO] [stdout]       |
[INFO] [stdout] 12933 |                           let output: i16 = ::glam::I16Vec2::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12934 | |                                 _self.into_inner(),
[INFO] [stdout] 12935 | |                             )
[INFO] [stdout] 12936 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12935 -                             )
[INFO] [stdout] 12936 -                             .into();
[INFO] [stdout] 12935 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12933 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_product(
[INFO] [stdout] 12934 |                                 _self.into_inner(),
[INFO] [stdout] 12935 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12950:43
[INFO] [stdout]       |
[INFO] [stdout] 12950 |                           let output: i16 = ::glam::I16Vec2::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12951 | |                                 _self.into_inner(),
[INFO] [stdout] 12952 | |                             )
[INFO] [stdout] 12953 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12952 -                             )
[INFO] [stdout] 12953 -                             .into();
[INFO] [stdout] 12952 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12950 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_sum(
[INFO] [stdout] 12951 |                                 _self.into_inner(),
[INFO] [stdout] 12952 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11804:45
[INFO] [stdout]       |
[INFO] [stdout] 11804 |                           let output: usize = ::glam::I8Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11805 | |                                 _self.into_inner(),
[INFO] [stdout] 11806 | |                             )
[INFO] [stdout] 11807 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11806 -                             )
[INFO] [stdout] 11807 -                             .into();
[INFO] [stdout] 11806 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11804 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::min_position(
[INFO] [stdout] 11805 |                                 _self.into_inner(),
[INFO] [stdout] 11806 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 4]`
[INFO] [stdout]      --> src/lib.rs:12186:47
[INFO] [stdout]       |
[INFO] [stdout] 12186 |                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = <[i8; 4] as Into<_>>::into(::glam::I8Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:12626:43
[INFO] [stdout]       |
[INFO] [stdout] 12626 |                           let output: u16 = ::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12627 | |                                 _self.into_inner(),
[INFO] [stdout] 12628 | |                                 rhs.into_inner(),
[INFO] [stdout] 12629 | |                             )
[INFO] [stdout] 12630 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12629 -                             )
[INFO] [stdout] 12630 -                             .into();
[INFO] [stdout] 12629 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12626 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout] 12627 |                                 _self.into_inner(),
[INFO] [stdout] 12628 |                                 rhs.into_inner(),
[INFO] [stdout] 12629 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:12644:67
[INFO] [stdout]       |
[INFO] [stdout] 12644 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 12645 | |                                 _self.into_inner(),
[INFO] [stdout] 12646 | |                                 rhs.into_inner(),
[INFO] [stdout] 12647 | |                             )
[INFO] [stdout] 12648 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12647 -                             )
[INFO] [stdout] 12648 -                             .into();
[INFO] [stdout] 12647 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12644 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout] 12645 |                                 _self.into_inner(),
[INFO] [stdout] 12646 |                                 rhs.into_inner(),
[INFO] [stdout] 12647 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12810:43
[INFO] [stdout]       |
[INFO] [stdout] 12810 |                           let output: i16 = ::glam::I16Vec2::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12811 | |                                 _self.into_inner(),
[INFO] [stdout] 12812 | |                                 rhs.into_inner(),
[INFO] [stdout] 12813 | |                             )
[INFO] [stdout] 12814 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12813 -                             )
[INFO] [stdout] 12814 -                             .into();
[INFO] [stdout] 12813 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12810 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::distance_squared(
[INFO] [stdout] 12811 |                                 _self.into_inner(),
[INFO] [stdout] 12812 |                                 rhs.into_inner(),
[INFO] [stdout] 12813 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12897:43
[INFO] [stdout]       |
[INFO] [stdout] 12897 |                           let output: i16 = ::glam::I16Vec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12898 | |                                 _self.into_inner(),
[INFO] [stdout] 12899 | |                                 rhs.into_inner(),
[INFO] [stdout] 12900 | |                             )
[INFO] [stdout] 12901 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12900 -                             )
[INFO] [stdout] 12901 -                             .into();
[INFO] [stdout] 12900 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12897 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::dot(
[INFO] [stdout] 12898 |                                 _self.into_inner(),
[INFO] [stdout] 12899 |                                 rhs.into_inner(),
[INFO] [stdout] 12900 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12933:43
[INFO] [stdout]       |
[INFO] [stdout] 12933 |                           let output: i16 = ::glam::I16Vec2::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12934 | |                                 _self.into_inner(),
[INFO] [stdout] 12935 | |                             )
[INFO] [stdout] 12936 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12935 -                             )
[INFO] [stdout] 12936 -                             .into();
[INFO] [stdout] 12935 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12933 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_product(
[INFO] [stdout] 12934 |                                 _self.into_inner(),
[INFO] [stdout] 12935 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:12967:44
[INFO] [stdout]       |
[INFO] [stdout] 12967 |                           let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 12968 | |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12969 -                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 -                             .into();
[INFO] [stdout] 12969 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12967 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 12968 |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12950:43
[INFO] [stdout]       |
[INFO] [stdout] 12950 |                           let output: i16 = ::glam::I16Vec2::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12951 | |                                 _self.into_inner(),
[INFO] [stdout] 12952 | |                             )
[INFO] [stdout] 12953 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12952 -                             )
[INFO] [stdout] 12953 -                             .into();
[INFO] [stdout] 12952 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12950 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_sum(
[INFO] [stdout] 12951 |                                 _self.into_inner(),
[INFO] [stdout] 12952 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:12967:44
[INFO] [stdout]       |
[INFO] [stdout] 12967 |                           let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 12968 | |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12969 -                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 -                             .into();
[INFO] [stdout] 12969 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12967 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 12968 |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:13017:43
[INFO] [stdout]       |
[INFO] [stdout] 13017 |                           let output: u32 = ::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13018 | |                                 _self.into_inner(),
[INFO] [stdout] 13019 | |                             )
[INFO] [stdout] 13020 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13019 -                             )
[INFO] [stdout] 13020 -                             .into();
[INFO] [stdout] 13019 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13017 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout] 13018 |                                 _self.into_inner(),
[INFO] [stdout] 13019 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13051:43
[INFO] [stdout]       |
[INFO] [stdout] 13051 |                           let output: i16 = ::glam::I16Vec2::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13052 | |                                 _self.into_inner(),
[INFO] [stdout] 13053 | |                             )
[INFO] [stdout] 13054 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13053 -                             )
[INFO] [stdout] 13054 -                             .into();
[INFO] [stdout] 13053 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13051 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::length_squared(
[INFO] [stdout] 13052 |                                 _self.into_inner(),
[INFO] [stdout] 13053 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:13017:43
[INFO] [stdout]       |
[INFO] [stdout] 13017 |                           let output: u32 = ::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13018 | |                                 _self.into_inner(),
[INFO] [stdout] 13019 | |                             )
[INFO] [stdout] 13020 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13019 -                             )
[INFO] [stdout] 13020 -                             .into();
[INFO] [stdout] 13019 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13017 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout] 13018 |                                 _self.into_inner(),
[INFO] [stdout] 13019 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13051:43
[INFO] [stdout]       |
[INFO] [stdout] 13051 |                           let output: i16 = ::glam::I16Vec2::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13052 | |                                 _self.into_inner(),
[INFO] [stdout] 13053 | |                             )
[INFO] [stdout] 13054 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13053 -                             )
[INFO] [stdout] 13054 -                             .into();
[INFO] [stdout] 13053 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13051 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::length_squared(
[INFO] [stdout] 13052 |                                 _self.into_inner(),
[INFO] [stdout] 13053 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:13068:43
[INFO] [stdout]       |
[INFO] [stdout] 13068 |                           let output: u16 = ::glam::I16Vec2::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13069 | |                                 _self.into_inner(),
[INFO] [stdout] 13070 | |                                 rhs.into_inner(),
[INFO] [stdout] 13071 | |                             )
[INFO] [stdout] 13072 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13071 -                             )
[INFO] [stdout] 13072 -                             .into();
[INFO] [stdout] 13071 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13068 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::manhattan_distance(
[INFO] [stdout] 13069 |                                 _self.into_inner(),
[INFO] [stdout] 13070 |                                 rhs.into_inner(),
[INFO] [stdout] 13071 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:13068:43
[INFO] [stdout]       |
[INFO] [stdout] 13068 |                           let output: u16 = ::glam::I16Vec2::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13069 | |                                 _self.into_inner(),
[INFO] [stdout] 13070 | |                                 rhs.into_inner(),
[INFO] [stdout] 13071 | |                             )
[INFO] [stdout] 13072 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13071 -                             )
[INFO] [stdout] 13072 -                             .into();
[INFO] [stdout] 13071 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13068 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::manhattan_distance(
[INFO] [stdout] 13069 |                                 _self.into_inner(),
[INFO] [stdout] 13070 |                                 rhs.into_inner(),
[INFO] [stdout] 13071 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13104:43
[INFO] [stdout]       |
[INFO] [stdout] 13104 |                           let output: i16 = ::glam::I16Vec2::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13105 | |                                 _self.into_inner(),
[INFO] [stdout] 13106 | |                             )
[INFO] [stdout] 13107 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13106 -                             )
[INFO] [stdout] 13107 -                             .into();
[INFO] [stdout] 13106 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13104 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::max_element(
[INFO] [stdout] 13105 |                                 _self.into_inner(),
[INFO] [stdout] 13106 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13104:43
[INFO] [stdout]       |
[INFO] [stdout] 13104 |                           let output: i16 = ::glam::I16Vec2::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13105 | |                                 _self.into_inner(),
[INFO] [stdout] 13106 | |                             )
[INFO] [stdout] 13107 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13106 -                             )
[INFO] [stdout] 13107 -                             .into();
[INFO] [stdout] 13106 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13104 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::max_element(
[INFO] [stdout] 13105 |                                 _self.into_inner(),
[INFO] [stdout] 13106 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13121:45
[INFO] [stdout]       |
[INFO] [stdout] 13121 |                           let output: usize = ::glam::I16Vec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13122 | |                                 _self.into_inner(),
[INFO] [stdout] 13123 | |                             )
[INFO] [stdout] 13124 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13123 -                             )
[INFO] [stdout] 13124 -                             .into();
[INFO] [stdout] 13123 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13121 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::max_position(
[INFO] [stdout] 13122 |                                 _self.into_inner(),
[INFO] [stdout] 13123 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13121:45
[INFO] [stdout]       |
[INFO] [stdout] 13121 |                           let output: usize = ::glam::I16Vec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13122 | |                                 _self.into_inner(),
[INFO] [stdout] 13123 | |                             )
[INFO] [stdout] 13124 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13123 -                             )
[INFO] [stdout] 13124 -                             .into();
[INFO] [stdout] 13123 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13121 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::max_position(
[INFO] [stdout] 13122 |                                 _self.into_inner(),
[INFO] [stdout] 13123 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13156:43
[INFO] [stdout]       |
[INFO] [stdout] 13156 |                           let output: i16 = ::glam::I16Vec2::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13157 | |                                 _self.into_inner(),
[INFO] [stdout] 13158 | |                             )
[INFO] [stdout] 13159 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13158 -                             )
[INFO] [stdout] 13159 -                             .into();
[INFO] [stdout] 13158 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13156 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::min_element(
[INFO] [stdout] 13157 |                                 _self.into_inner(),
[INFO] [stdout] 13158 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13173:45
[INFO] [stdout]       |
[INFO] [stdout] 13173 |                           let output: usize = ::glam::I16Vec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13174 | |                                 _self.into_inner(),
[INFO] [stdout] 13175 | |                             )
[INFO] [stdout] 13176 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13175 -                             )
[INFO] [stdout] 13176 -                             .into();
[INFO] [stdout] 13175 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13173 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::min_position(
[INFO] [stdout] 13174 |                                 _self.into_inner(),
[INFO] [stdout] 13175 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13290:43
[INFO] [stdout]       |
[INFO] [stdout] 13290 |                           let output: i16 = ::glam::I16Vec2::perp_dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13291 | |                                 _self.into_inner(),
[INFO] [stdout] 13292 | |                                 rhs.into_inner(),
[INFO] [stdout] 13293 | |                             )
[INFO] [stdout] 13294 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13293 -                             )
[INFO] [stdout] 13294 -                             .into();
[INFO] [stdout] 13293 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13290 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::perp_dot(
[INFO] [stdout] 13291 |                                 _self.into_inner(),
[INFO] [stdout] 13292 |                                 rhs.into_inner(),
[INFO] [stdout] 13293 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 2]`
[INFO] [stdout]      --> src/lib.rs:13609:48
[INFO] [stdout]       |
[INFO] [stdout] 13609 |                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = <[i16; 2] as Into<_>>::into(::glam::I16Vec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14013:43
[INFO] [stdout]       |
[INFO] [stdout] 14013 |                           let output: u16 = ::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14014 | |                                 _self.into_inner(),
[INFO] [stdout] 14015 | |                                 rhs.into_inner(),
[INFO] [stdout] 14016 | |                             )
[INFO] [stdout] 14017 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14016 -                             )
[INFO] [stdout] 14017 -                             .into();
[INFO] [stdout] 14016 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14013 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout] 14014 |                                 _self.into_inner(),
[INFO] [stdout] 14015 |                                 rhs.into_inner(),
[INFO] [stdout] 14016 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:14031:67
[INFO] [stdout]       |
[INFO] [stdout] 14031 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 14032 | |                                 _self.into_inner(),
[INFO] [stdout] 14033 | |                                 rhs.into_inner(),
[INFO] [stdout] 14034 | |                             )
[INFO] [stdout] 14035 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14034 -                             )
[INFO] [stdout] 14035 -                             .into();
[INFO] [stdout] 14034 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14031 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout] 14032 |                                 _self.into_inner(),
[INFO] [stdout] 14033 |                                 rhs.into_inner(),
[INFO] [stdout] 14034 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13156:43
[INFO] [stdout]       |
[INFO] [stdout] 13156 |                           let output: i16 = ::glam::I16Vec2::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13157 | |                                 _self.into_inner(),
[INFO] [stdout] 13158 | |                             )
[INFO] [stdout] 13159 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13158 -                             )
[INFO] [stdout] 13159 -                             .into();
[INFO] [stdout] 13158 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13156 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::min_element(
[INFO] [stdout] 13157 |                                 _self.into_inner(),
[INFO] [stdout] 13158 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13173:45
[INFO] [stdout]       |
[INFO] [stdout] 13173 |                           let output: usize = ::glam::I16Vec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13174 | |                                 _self.into_inner(),
[INFO] [stdout] 13175 | |                             )
[INFO] [stdout] 13176 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13175 -                             )
[INFO] [stdout] 13176 -                             .into();
[INFO] [stdout] 13175 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13173 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::min_position(
[INFO] [stdout] 13174 |                                 _self.into_inner(),
[INFO] [stdout] 13175 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13290:43
[INFO] [stdout]       |
[INFO] [stdout] 13290 |                           let output: i16 = ::glam::I16Vec2::perp_dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13291 | |                                 _self.into_inner(),
[INFO] [stdout] 13292 | |                                 rhs.into_inner(),
[INFO] [stdout] 13293 | |                             )
[INFO] [stdout] 13294 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13293 -                             )
[INFO] [stdout] 13294 -                             .into();
[INFO] [stdout] 13293 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13290 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::perp_dot(
[INFO] [stdout] 13291 |                                 _self.into_inner(),
[INFO] [stdout] 13292 |                                 rhs.into_inner(),
[INFO] [stdout] 13293 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 2]`
[INFO] [stdout]      --> src/lib.rs:13609:48
[INFO] [stdout]       |
[INFO] [stdout] 13609 |                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = <[i16; 2] as Into<_>>::into(::glam::I16Vec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14013:43
[INFO] [stdout]       |
[INFO] [stdout] 14013 |                           let output: u16 = ::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14014 | |                                 _self.into_inner(),
[INFO] [stdout] 14015 | |                                 rhs.into_inner(),
[INFO] [stdout] 14016 | |                             )
[INFO] [stdout] 14017 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14016 -                             )
[INFO] [stdout] 14017 -                             .into();
[INFO] [stdout] 14016 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14013 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout] 14014 |                                 _self.into_inner(),
[INFO] [stdout] 14015 |                                 rhs.into_inner(),
[INFO] [stdout] 14016 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:14031:67
[INFO] [stdout]       |
[INFO] [stdout] 14031 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 14032 | |                                 _self.into_inner(),
[INFO] [stdout] 14033 | |                                 rhs.into_inner(),
[INFO] [stdout] 14034 | |                             )
[INFO] [stdout] 14035 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14034 -                             )
[INFO] [stdout] 14035 -                             .into();
[INFO] [stdout] 14034 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14031 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout] 14032 |                                 _self.into_inner(),
[INFO] [stdout] 14033 |                                 rhs.into_inner(),
[INFO] [stdout] 14034 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14215:43
[INFO] [stdout]       |
[INFO] [stdout] 14215 |                           let output: i16 = ::glam::I16Vec3::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14216 | |                                 _self.into_inner(),
[INFO] [stdout] 14217 | |                                 rhs.into_inner(),
[INFO] [stdout] 14218 | |                             )
[INFO] [stdout] 14219 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14218 -                             )
[INFO] [stdout] 14219 -                             .into();
[INFO] [stdout] 14218 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14215 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::distance_squared(
[INFO] [stdout] 14216 |                                 _self.into_inner(),
[INFO] [stdout] 14217 |                                 rhs.into_inner(),
[INFO] [stdout] 14218 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14302:43
[INFO] [stdout]       |
[INFO] [stdout] 14302 |                           let output: i16 = ::glam::I16Vec3::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14303 | |                                 _self.into_inner(),
[INFO] [stdout] 14304 | |                                 rhs.into_inner(),
[INFO] [stdout] 14305 | |                             )
[INFO] [stdout] 14306 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14305 -                             )
[INFO] [stdout] 14306 -                             .into();
[INFO] [stdout] 14305 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14302 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::dot(
[INFO] [stdout] 14303 |                                 _self.into_inner(),
[INFO] [stdout] 14304 |                                 rhs.into_inner(),
[INFO] [stdout] 14305 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14338:43
[INFO] [stdout]       |
[INFO] [stdout] 14338 |                           let output: i16 = ::glam::I16Vec3::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14339 | |                                 _self.into_inner(),
[INFO] [stdout] 14340 | |                             )
[INFO] [stdout] 14341 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14340 -                             )
[INFO] [stdout] 14341 -                             .into();
[INFO] [stdout] 14340 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14338 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_product(
[INFO] [stdout] 14339 |                                 _self.into_inner(),
[INFO] [stdout] 14340 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14355:43
[INFO] [stdout]       |
[INFO] [stdout] 14355 |                           let output: i16 = ::glam::I16Vec3::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14356 | |                                 _self.into_inner(),
[INFO] [stdout] 14357 | |                             )
[INFO] [stdout] 14358 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14357 -                             )
[INFO] [stdout] 14358 -                             .into();
[INFO] [stdout] 14357 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14355 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_sum(
[INFO] [stdout] 14356 |                                 _self.into_inner(),
[INFO] [stdout] 14357 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:14372:44
[INFO] [stdout]       |
[INFO] [stdout] 14372 |                           let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 14373 | |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14374 -                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 -                             .into();
[INFO] [stdout] 14374 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14372 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 14373 |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:14422:43
[INFO] [stdout]       |
[INFO] [stdout] 14422 |                           let output: u32 = ::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14423 | |                                 _self.into_inner(),
[INFO] [stdout] 14424 | |                             )
[INFO] [stdout] 14425 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14424 -                             )
[INFO] [stdout] 14425 -                             .into();
[INFO] [stdout] 14424 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14422 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout] 14423 |                                 _self.into_inner(),
[INFO] [stdout] 14424 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14456:43
[INFO] [stdout]       |
[INFO] [stdout] 14456 |                           let output: i16 = ::glam::I16Vec3::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14457 | |                                 _self.into_inner(),
[INFO] [stdout] 14458 | |                             )
[INFO] [stdout] 14459 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14458 -                             )
[INFO] [stdout] 14459 -                             .into();
[INFO] [stdout] 14458 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14456 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::length_squared(
[INFO] [stdout] 14457 |                                 _self.into_inner(),
[INFO] [stdout] 14458 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14473:43
[INFO] [stdout]       |
[INFO] [stdout] 14473 |                           let output: u16 = ::glam::I16Vec3::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14474 | |                                 _self.into_inner(),
[INFO] [stdout] 14475 | |                                 rhs.into_inner(),
[INFO] [stdout] 14476 | |                             )
[INFO] [stdout] 14477 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14476 -                             )
[INFO] [stdout] 14477 -                             .into();
[INFO] [stdout] 14476 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14473 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::manhattan_distance(
[INFO] [stdout] 14474 |                                 _self.into_inner(),
[INFO] [stdout] 14475 |                                 rhs.into_inner(),
[INFO] [stdout] 14476 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14509:43
[INFO] [stdout]       |
[INFO] [stdout] 14509 |                           let output: i16 = ::glam::I16Vec3::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14510 | |                                 _self.into_inner(),
[INFO] [stdout] 14511 | |                             )
[INFO] [stdout] 14512 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14511 -                             )
[INFO] [stdout] 14512 -                             .into();
[INFO] [stdout] 14511 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14509 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::max_element(
[INFO] [stdout] 14510 |                                 _self.into_inner(),
[INFO] [stdout] 14511 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14215:43
[INFO] [stdout]       |
[INFO] [stdout] 14215 |                           let output: i16 = ::glam::I16Vec3::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14216 | |                                 _self.into_inner(),
[INFO] [stdout] 14217 | |                                 rhs.into_inner(),
[INFO] [stdout] 14218 | |                             )
[INFO] [stdout] 14219 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14218 -                             )
[INFO] [stdout] 14219 -                             .into();
[INFO] [stdout] 14218 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14215 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::distance_squared(
[INFO] [stdout] 14216 |                                 _self.into_inner(),
[INFO] [stdout] 14217 |                                 rhs.into_inner(),
[INFO] [stdout] 14218 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14302:43
[INFO] [stdout]       |
[INFO] [stdout] 14302 |                           let output: i16 = ::glam::I16Vec3::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14303 | |                                 _self.into_inner(),
[INFO] [stdout] 14304 | |                                 rhs.into_inner(),
[INFO] [stdout] 14305 | |                             )
[INFO] [stdout] 14306 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14305 -                             )
[INFO] [stdout] 14306 -                             .into();
[INFO] [stdout] 14305 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14302 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::dot(
[INFO] [stdout] 14303 |                                 _self.into_inner(),
[INFO] [stdout] 14304 |                                 rhs.into_inner(),
[INFO] [stdout] 14305 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14338:43
[INFO] [stdout]       |
[INFO] [stdout] 14338 |                           let output: i16 = ::glam::I16Vec3::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14339 | |                                 _self.into_inner(),
[INFO] [stdout] 14340 | |                             )
[INFO] [stdout] 14341 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14340 -                             )
[INFO] [stdout] 14341 -                             .into();
[INFO] [stdout] 14340 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14338 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_product(
[INFO] [stdout] 14339 |                                 _self.into_inner(),
[INFO] [stdout] 14340 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14355:43
[INFO] [stdout]       |
[INFO] [stdout] 14355 |                           let output: i16 = ::glam::I16Vec3::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14356 | |                                 _self.into_inner(),
[INFO] [stdout] 14357 | |                             )
[INFO] [stdout] 14358 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14357 -                             )
[INFO] [stdout] 14358 -                             .into();
[INFO] [stdout] 14357 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14355 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_sum(
[INFO] [stdout] 14356 |                                 _self.into_inner(),
[INFO] [stdout] 14357 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:14372:44
[INFO] [stdout]       |
[INFO] [stdout] 14372 |                           let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 14373 | |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14374 -                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 -                             .into();
[INFO] [stdout] 14374 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14372 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 14373 |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:14422:43
[INFO] [stdout]       |
[INFO] [stdout] 14422 |                           let output: u32 = ::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14423 | |                                 _self.into_inner(),
[INFO] [stdout] 14424 | |                             )
[INFO] [stdout] 14425 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14424 -                             )
[INFO] [stdout] 14425 -                             .into();
[INFO] [stdout] 14424 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14422 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout] 14423 |                                 _self.into_inner(),
[INFO] [stdout] 14424 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14456:43
[INFO] [stdout]       |
[INFO] [stdout] 14456 |                           let output: i16 = ::glam::I16Vec3::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14457 | |                                 _self.into_inner(),
[INFO] [stdout] 14458 | |                             )
[INFO] [stdout] 14459 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14458 -                             )
[INFO] [stdout] 14459 -                             .into();
[INFO] [stdout] 14458 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14456 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::length_squared(
[INFO] [stdout] 14457 |                                 _self.into_inner(),
[INFO] [stdout] 14458 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14526:45
[INFO] [stdout]       |
[INFO] [stdout] 14526 |                           let output: usize = ::glam::I16Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14527 | |                                 _self.into_inner(),
[INFO] [stdout] 14528 | |                             )
[INFO] [stdout] 14529 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14528 -                             )
[INFO] [stdout] 14529 -                             .into();
[INFO] [stdout] 14528 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14526 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::max_position(
[INFO] [stdout] 14527 |                                 _self.into_inner(),
[INFO] [stdout] 14528 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14561:43
[INFO] [stdout]       |
[INFO] [stdout] 14561 |                           let output: i16 = ::glam::I16Vec3::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14562 | |                                 _self.into_inner(),
[INFO] [stdout] 14563 | |                             )
[INFO] [stdout] 14564 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14563 -                             )
[INFO] [stdout] 14564 -                             .into();
[INFO] [stdout] 14563 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14561 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::min_element(
[INFO] [stdout] 14562 |                                 _self.into_inner(),
[INFO] [stdout] 14563 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14578:45
[INFO] [stdout]       |
[INFO] [stdout] 14578 |                           let output: usize = ::glam::I16Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14579 | |                                 _self.into_inner(),
[INFO] [stdout] 14580 | |                             )
[INFO] [stdout] 14581 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14580 -                             )
[INFO] [stdout] 14581 -                             .into();
[INFO] [stdout] 14580 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14578 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::min_position(
[INFO] [stdout] 14579 |                                 _self.into_inner(),
[INFO] [stdout] 14580 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 3]`
[INFO] [stdout]      --> src/lib.rs:14961:48
[INFO] [stdout]       |
[INFO] [stdout] 14961 |                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = <[i16; 3] as Into<_>>::into(::glam::I16Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15383:43
[INFO] [stdout]       |
[INFO] [stdout] 15383 |                           let output: u16 = ::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15384 | |                                 _self.into_inner(),
[INFO] [stdout] 15385 | |                                 rhs.into_inner(),
[INFO] [stdout] 15386 | |                             )
[INFO] [stdout] 15387 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15386 -                             )
[INFO] [stdout] 15387 -                             .into();
[INFO] [stdout] 15386 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15383 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout] 15384 |                                 _self.into_inner(),
[INFO] [stdout] 15385 |                                 rhs.into_inner(),
[INFO] [stdout] 15386 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:15401:67
[INFO] [stdout]       |
[INFO] [stdout] 15401 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 15402 | |                                 _self.into_inner(),
[INFO] [stdout] 15403 | |                                 rhs.into_inner(),
[INFO] [stdout] 15404 | |                             )
[INFO] [stdout] 15405 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15404 -                             )
[INFO] [stdout] 15405 -                             .into();
[INFO] [stdout] 15404 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15401 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout] 15402 |                                 _self.into_inner(),
[INFO] [stdout] 15403 |                                 rhs.into_inner(),
[INFO] [stdout] 15404 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15567:43
[INFO] [stdout]       |
[INFO] [stdout] 15567 |                           let output: i16 = ::glam::I16Vec4::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15568 | |                                 _self.into_inner(),
[INFO] [stdout] 15569 | |                                 rhs.into_inner(),
[INFO] [stdout] 15570 | |                             )
[INFO] [stdout] 15571 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15570 -                             )
[INFO] [stdout] 15571 -                             .into();
[INFO] [stdout] 15570 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15567 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::distance_squared(
[INFO] [stdout] 15568 |                                 _self.into_inner(),
[INFO] [stdout] 15569 |                                 rhs.into_inner(),
[INFO] [stdout] 15570 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14473:43
[INFO] [stdout]       |
[INFO] [stdout] 14473 |                           let output: u16 = ::glam::I16Vec3::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14474 | |                                 _self.into_inner(),
[INFO] [stdout] 14475 | |                                 rhs.into_inner(),
[INFO] [stdout] 14476 | |                             )
[INFO] [stdout] 14477 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14476 -                             )
[INFO] [stdout] 14477 -                             .into();
[INFO] [stdout] 14476 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14473 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::manhattan_distance(
[INFO] [stdout] 14474 |                                 _self.into_inner(),
[INFO] [stdout] 14475 |                                 rhs.into_inner(),
[INFO] [stdout] 14476 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15654:43
[INFO] [stdout]       |
[INFO] [stdout] 15654 |                           let output: i16 = ::glam::I16Vec4::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15655 | |                                 _self.into_inner(),
[INFO] [stdout] 15656 | |                                 rhs.into_inner(),
[INFO] [stdout] 15657 | |                             )
[INFO] [stdout] 15658 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15657 -                             )
[INFO] [stdout] 15658 -                             .into();
[INFO] [stdout] 15657 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15654 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::dot(
[INFO] [stdout] 15655 |                                 _self.into_inner(),
[INFO] [stdout] 15656 |                                 rhs.into_inner(),
[INFO] [stdout] 15657 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14509:43
[INFO] [stdout]       |
[INFO] [stdout] 14509 |                           let output: i16 = ::glam::I16Vec3::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14510 | |                                 _self.into_inner(),
[INFO] [stdout] 14511 | |                             )
[INFO] [stdout] 14512 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14511 -                             )
[INFO] [stdout] 14512 -                             .into();
[INFO] [stdout] 14511 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14509 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::max_element(
[INFO] [stdout] 14510 |                                 _self.into_inner(),
[INFO] [stdout] 14511 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14526:45
[INFO] [stdout]       |
[INFO] [stdout] 14526 |                           let output: usize = ::glam::I16Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14527 | |                                 _self.into_inner(),
[INFO] [stdout] 14528 | |                             )
[INFO] [stdout] 14529 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14528 -                             )
[INFO] [stdout] 14529 -                             .into();
[INFO] [stdout] 14528 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14526 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::max_position(
[INFO] [stdout] 14527 |                                 _self.into_inner(),
[INFO] [stdout] 14528 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15690:43
[INFO] [stdout]       |
[INFO] [stdout] 15690 |                           let output: i16 = ::glam::I16Vec4::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15691 | |                                 _self.into_inner(),
[INFO] [stdout] 15692 | |                             )
[INFO] [stdout] 15693 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15692 -                             )
[INFO] [stdout] 15693 -                             .into();
[INFO] [stdout] 15692 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15690 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_product(
[INFO] [stdout] 15691 |                                 _self.into_inner(),
[INFO] [stdout] 15692 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15707:43
[INFO] [stdout]       |
[INFO] [stdout] 15707 |                           let output: i16 = ::glam::I16Vec4::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15708 | |                                 _self.into_inner(),
[INFO] [stdout] 15709 | |                             )
[INFO] [stdout] 15710 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15709 -                             )
[INFO] [stdout] 15710 -                             .into();
[INFO] [stdout] 15709 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15707 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_sum(
[INFO] [stdout] 15708 |                                 _self.into_inner(),
[INFO] [stdout] 15709 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14561:43
[INFO] [stdout]       |
[INFO] [stdout] 14561 |                           let output: i16 = ::glam::I16Vec3::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14562 | |                                 _self.into_inner(),
[INFO] [stdout] 14563 | |                             )
[INFO] [stdout] 14564 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14563 -                             )
[INFO] [stdout] 14564 -                             .into();
[INFO] [stdout] 14563 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14561 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::min_element(
[INFO] [stdout] 14562 |                                 _self.into_inner(),
[INFO] [stdout] 14563 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14578:45
[INFO] [stdout]       |
[INFO] [stdout] 14578 |                           let output: usize = ::glam::I16Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14579 | |                                 _self.into_inner(),
[INFO] [stdout] 14580 | |                             )
[INFO] [stdout] 14581 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14580 -                             )
[INFO] [stdout] 14581 -                             .into();
[INFO] [stdout] 14580 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14578 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::min_position(
[INFO] [stdout] 14579 |                                 _self.into_inner(),
[INFO] [stdout] 14580 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:15724:44
[INFO] [stdout]       |
[INFO] [stdout] 15724 |                           let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 15725 | |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15726 -                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 -                             .into();
[INFO] [stdout] 15726 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15724 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 15725 |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 3]`
[INFO] [stdout]      --> src/lib.rs:14961:48
[INFO] [stdout]       |
[INFO] [stdout] 14961 |                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = <[i16; 3] as Into<_>>::into(::glam::I16Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:15756:43
[INFO] [stdout]       |
[INFO] [stdout] 15756 |                           let output: u32 = ::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15757 | |                                 _self.into_inner(),
[INFO] [stdout] 15758 | |                             )
[INFO] [stdout] 15759 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15758 -                             )
[INFO] [stdout] 15759 -                             .into();
[INFO] [stdout] 15758 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15756 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout] 15757 |                                 _self.into_inner(),
[INFO] [stdout] 15758 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15383:43
[INFO] [stdout]       |
[INFO] [stdout] 15383 |                           let output: u16 = ::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15384 | |                                 _self.into_inner(),
[INFO] [stdout] 15385 | |                                 rhs.into_inner(),
[INFO] [stdout] 15386 | |                             )
[INFO] [stdout] 15387 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15386 -                             )
[INFO] [stdout] 15387 -                             .into();
[INFO] [stdout] 15386 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15383 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout] 15384 |                                 _self.into_inner(),
[INFO] [stdout] 15385 |                                 rhs.into_inner(),
[INFO] [stdout] 15386 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:15401:67
[INFO] [stdout]       |
[INFO] [stdout] 15401 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 15402 | |                                 _self.into_inner(),
[INFO] [stdout] 15403 | |                                 rhs.into_inner(),
[INFO] [stdout] 15404 | |                             )
[INFO] [stdout] 15405 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15404 -                             )
[INFO] [stdout] 15405 -                             .into();
[INFO] [stdout] 15404 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15401 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout] 15402 |                                 _self.into_inner(),
[INFO] [stdout] 15403 |                                 rhs.into_inner(),
[INFO] [stdout] 15404 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15567:43
[INFO] [stdout]       |
[INFO] [stdout] 15567 |                           let output: i16 = ::glam::I16Vec4::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15568 | |                                 _self.into_inner(),
[INFO] [stdout] 15569 | |                                 rhs.into_inner(),
[INFO] [stdout] 15570 | |                             )
[INFO] [stdout] 15571 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15570 -                             )
[INFO] [stdout] 15571 -                             .into();
[INFO] [stdout] 15570 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15567 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::distance_squared(
[INFO] [stdout] 15568 |                                 _self.into_inner(),
[INFO] [stdout] 15569 |                                 rhs.into_inner(),
[INFO] [stdout] 15570 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15654:43
[INFO] [stdout]       |
[INFO] [stdout] 15654 |                           let output: i16 = ::glam::I16Vec4::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15655 | |                                 _self.into_inner(),
[INFO] [stdout] 15656 | |                                 rhs.into_inner(),
[INFO] [stdout] 15657 | |                             )
[INFO] [stdout] 15658 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15657 -                             )
[INFO] [stdout] 15658 -                             .into();
[INFO] [stdout] 15657 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15654 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::dot(
[INFO] [stdout] 15655 |                                 _self.into_inner(),
[INFO] [stdout] 15656 |                                 rhs.into_inner(),
[INFO] [stdout] 15657 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15690:43
[INFO] [stdout]       |
[INFO] [stdout] 15690 |                           let output: i16 = ::glam::I16Vec4::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15691 | |                                 _self.into_inner(),
[INFO] [stdout] 15692 | |                             )
[INFO] [stdout] 15693 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15692 -                             )
[INFO] [stdout] 15693 -                             .into();
[INFO] [stdout] 15692 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15690 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_product(
[INFO] [stdout] 15691 |                                 _self.into_inner(),
[INFO] [stdout] 15692 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15790:43
[INFO] [stdout]       |
[INFO] [stdout] 15790 |                           let output: i16 = ::glam::I16Vec4::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15791 | |                                 _self.into_inner(),
[INFO] [stdout] 15792 | |                             )
[INFO] [stdout] 15793 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15792 -                             )
[INFO] [stdout] 15793 -                             .into();
[INFO] [stdout] 15792 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15790 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::length_squared(
[INFO] [stdout] 15791 |                                 _self.into_inner(),
[INFO] [stdout] 15792 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15707:43
[INFO] [stdout]       |
[INFO] [stdout] 15707 |                           let output: i16 = ::glam::I16Vec4::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15708 | |                                 _self.into_inner(),
[INFO] [stdout] 15709 | |                             )
[INFO] [stdout] 15710 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15709 -                             )
[INFO] [stdout] 15710 -                             .into();
[INFO] [stdout] 15709 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15707 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_sum(
[INFO] [stdout] 15708 |                                 _self.into_inner(),
[INFO] [stdout] 15709 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15807:43
[INFO] [stdout]       |
[INFO] [stdout] 15807 |                           let output: u16 = ::glam::I16Vec4::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15808 | |                                 _self.into_inner(),
[INFO] [stdout] 15809 | |                                 rhs.into_inner(),
[INFO] [stdout] 15810 | |                             )
[INFO] [stdout] 15811 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15810 -                             )
[INFO] [stdout] 15811 -                             .into();
[INFO] [stdout] 15810 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15807 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::manhattan_distance(
[INFO] [stdout] 15808 |                                 _self.into_inner(),
[INFO] [stdout] 15809 |                                 rhs.into_inner(),
[INFO] [stdout] 15810 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15843:43
[INFO] [stdout]       |
[INFO] [stdout] 15843 |                           let output: i16 = ::glam::I16Vec4::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15844 | |                                 _self.into_inner(),
[INFO] [stdout] 15845 | |                             )
[INFO] [stdout] 15846 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15845 -                             )
[INFO] [stdout] 15846 -                             .into();
[INFO] [stdout] 15845 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15843 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::max_element(
[INFO] [stdout] 15844 |                                 _self.into_inner(),
[INFO] [stdout] 15845 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:15724:44
[INFO] [stdout]       |
[INFO] [stdout] 15724 |                           let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 15725 | |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15726 -                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 -                             .into();
[INFO] [stdout] 15726 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15724 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 15725 |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15860:45
[INFO] [stdout]       |
[INFO] [stdout] 15860 |                           let output: usize = ::glam::I16Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15861 | |                                 _self.into_inner(),
[INFO] [stdout] 15862 | |                             )
[INFO] [stdout] 15863 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15862 -                             )
[INFO] [stdout] 15863 -                             .into();
[INFO] [stdout] 15862 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15860 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::max_position(
[INFO] [stdout] 15861 |                                 _self.into_inner(),
[INFO] [stdout] 15862 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15895:43
[INFO] [stdout]       |
[INFO] [stdout] 15895 |                           let output: i16 = ::glam::I16Vec4::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15896 | |                                 _self.into_inner(),
[INFO] [stdout] 15897 | |                             )
[INFO] [stdout] 15898 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15897 -                             )
[INFO] [stdout] 15898 -                             .into();
[INFO] [stdout] 15897 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15895 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::min_element(
[INFO] [stdout] 15896 |                                 _self.into_inner(),
[INFO] [stdout] 15897 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:15756:43
[INFO] [stdout]       |
[INFO] [stdout] 15756 |                           let output: u32 = ::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15757 | |                                 _self.into_inner(),
[INFO] [stdout] 15758 | |                             )
[INFO] [stdout] 15759 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15758 -                             )
[INFO] [stdout] 15759 -                             .into();
[INFO] [stdout] 15758 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15756 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout] 15757 |                                 _self.into_inner(),
[INFO] [stdout] 15758 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15790:43
[INFO] [stdout]       |
[INFO] [stdout] 15790 |                           let output: i16 = ::glam::I16Vec4::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15791 | |                                 _self.into_inner(),
[INFO] [stdout] 15792 | |                             )
[INFO] [stdout] 15793 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15792 -                             )
[INFO] [stdout] 15793 -                             .into();
[INFO] [stdout] 15792 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15790 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::length_squared(
[INFO] [stdout] 15791 |                                 _self.into_inner(),
[INFO] [stdout] 15792 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15912:45
[INFO] [stdout]       |
[INFO] [stdout] 15912 |                           let output: usize = ::glam::I16Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15913 | |                                 _self.into_inner(),
[INFO] [stdout] 15914 | |                             )
[INFO] [stdout] 15915 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15914 -                             )
[INFO] [stdout] 15915 -                             .into();
[INFO] [stdout] 15914 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15912 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::min_position(
[INFO] [stdout] 15913 |                                 _self.into_inner(),
[INFO] [stdout] 15914 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 4]`
[INFO] [stdout]      --> src/lib.rs:16295:48
[INFO] [stdout]       |
[INFO] [stdout] 16295 |                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = <[i16; 4] as Into<_>>::into(::glam::I16Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15807:43
[INFO] [stdout]       |
[INFO] [stdout] 15807 |                           let output: u16 = ::glam::I16Vec4::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15808 | |                                 _self.into_inner(),
[INFO] [stdout] 15809 | |                                 rhs.into_inner(),
[INFO] [stdout] 15810 | |                             )
[INFO] [stdout] 15811 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15810 -                             )
[INFO] [stdout] 15811 -                             .into();
[INFO] [stdout] 15810 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15807 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::manhattan_distance(
[INFO] [stdout] 15808 |                                 _self.into_inner(),
[INFO] [stdout] 15809 |                                 rhs.into_inner(),
[INFO] [stdout] 15810 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:16735:43
[INFO] [stdout]       |
[INFO] [stdout] 16735 |                           let output: u64 = ::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 16736 | |                                 _self.into_inner(),
[INFO] [stdout] 16737 | |                                 rhs.into_inner(),
[INFO] [stdout] 16738 | |                             )
[INFO] [stdout] 16739 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16738 -                             )
[INFO] [stdout] 16739 -                             .into();
[INFO] [stdout] 16738 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16735 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout] 16736 |                                 _self.into_inner(),
[INFO] [stdout] 16737 |                                 rhs.into_inner(),
[INFO] [stdout] 16738 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15843:43
[INFO] [stdout]       |
[INFO] [stdout] 15843 |                           let output: i16 = ::glam::I16Vec4::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15844 | |                                 _self.into_inner(),
[INFO] [stdout] 15845 | |                             )
[INFO] [stdout] 15846 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15845 -                             )
[INFO] [stdout] 15846 -                             .into();
[INFO] [stdout] 15845 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15843 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::max_element(
[INFO] [stdout] 15844 |                                 _self.into_inner(),
[INFO] [stdout] 15845 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15860:45
[INFO] [stdout]       |
[INFO] [stdout] 15860 |                           let output: usize = ::glam::I16Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15861 | |                                 _self.into_inner(),
[INFO] [stdout] 15862 | |                             )
[INFO] [stdout] 15863 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15862 -                             )
[INFO] [stdout] 15863 -                             .into();
[INFO] [stdout] 15862 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15860 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::max_position(
[INFO] [stdout] 15861 |                                 _self.into_inner(),
[INFO] [stdout] 15862 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u64>`
[INFO] [stdout]      --> src/lib.rs:16753:67
[INFO] [stdout]       |
[INFO] [stdout] 16753 |                           let output: ::core::option::Option<u64> = ::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 16754 | |                                 _self.into_inner(),
[INFO] [stdout] 16755 | |                                 rhs.into_inner(),
[INFO] [stdout] 16756 | |                             )
[INFO] [stdout] 16757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16756 -                             )
[INFO] [stdout] 16757 -                             .into();
[INFO] [stdout] 16756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16753 ~                         let output: ::core::option::Option<u64> = <std::option::Option<u64> as Into<_>>::into(::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout] 16754 |                                 _self.into_inner(),
[INFO] [stdout] 16755 |                                 rhs.into_inner(),
[INFO] [stdout] 16756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15895:43
[INFO] [stdout]       |
[INFO] [stdout] 15895 |                           let output: i16 = ::glam::I16Vec4::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15896 | |                                 _self.into_inner(),
[INFO] [stdout] 15897 | |                             )
[INFO] [stdout] 15898 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15897 -                             )
[INFO] [stdout] 15898 -                             .into();
[INFO] [stdout] 15897 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15895 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::min_element(
[INFO] [stdout] 15896 |                                 _self.into_inner(),
[INFO] [stdout] 15897 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:16919:43
[INFO] [stdout]       |
[INFO] [stdout] 16919 |                           let output: i64 = ::glam::I64Vec2::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 16920 | |                                 _self.into_inner(),
[INFO] [stdout] 16921 | |                                 rhs.into_inner(),
[INFO] [stdout] 16922 | |                             )
[INFO] [stdout] 16923 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16922 -                             )
[INFO] [stdout] 16923 -                             .into();
[INFO] [stdout] 16922 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16919 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::distance_squared(
[INFO] [stdout] 16920 |                                 _self.into_inner(),
[INFO] [stdout] 16921 |                                 rhs.into_inner(),
[INFO] [stdout] 16922 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15912:45
[INFO] [stdout]       |
[INFO] [stdout] 15912 |                           let output: usize = ::glam::I16Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15913 | |                                 _self.into_inner(),
[INFO] [stdout] 15914 | |                             )
[INFO] [stdout] 15915 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15914 -                             )
[INFO] [stdout] 15915 -                             .into();
[INFO] [stdout] 15914 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15912 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::min_position(
[INFO] [stdout] 15913 |                                 _self.into_inner(),
[INFO] [stdout] 15914 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17006:43
[INFO] [stdout]       |
[INFO] [stdout] 17006 |                           let output: i64 = ::glam::I64Vec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17007 | |                                 _self.into_inner(),
[INFO] [stdout] 17008 | |                                 rhs.into_inner(),
[INFO] [stdout] 17009 | |                             )
[INFO] [stdout] 17010 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17009 -                             )
[INFO] [stdout] 17010 -                             .into();
[INFO] [stdout] 17009 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17006 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::dot(
[INFO] [stdout] 17007 |                                 _self.into_inner(),
[INFO] [stdout] 17008 |                                 rhs.into_inner(),
[INFO] [stdout] 17009 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 4]`
[INFO] [stdout]      --> src/lib.rs:16295:48
[INFO] [stdout]       |
[INFO] [stdout] 16295 |                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = <[i16; 4] as Into<_>>::into(::glam::I16Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:16735:43
[INFO] [stdout]       |
[INFO] [stdout] 16735 |                           let output: u64 = ::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 16736 | |                                 _self.into_inner(),
[INFO] [stdout] 16737 | |                                 rhs.into_inner(),
[INFO] [stdout] 16738 | |                             )
[INFO] [stdout] 16739 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16738 -                             )
[INFO] [stdout] 16739 -                             .into();
[INFO] [stdout] 16738 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16735 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout] 16736 |                                 _self.into_inner(),
[INFO] [stdout] 16737 |                                 rhs.into_inner(),
[INFO] [stdout] 16738 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u64>`
[INFO] [stdout]      --> src/lib.rs:16753:67
[INFO] [stdout]       |
[INFO] [stdout] 16753 |                           let output: ::core::option::Option<u64> = ::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 16754 | |                                 _self.into_inner(),
[INFO] [stdout] 16755 | |                                 rhs.into_inner(),
[INFO] [stdout] 16756 | |                             )
[INFO] [stdout] 16757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16756 -                             )
[INFO] [stdout] 16757 -                             .into();
[INFO] [stdout] 16756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16753 ~                         let output: ::core::option::Option<u64> = <std::option::Option<u64> as Into<_>>::into(::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout] 16754 |                                 _self.into_inner(),
[INFO] [stdout] 16755 |                                 rhs.into_inner(),
[INFO] [stdout] 16756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[WARN] too many lines in the log, truncating it
