[INFO] fetching crate bevy_ui_bms_bindings 0.23.0...
[INFO] checking bevy_ui_bms_bindings-0.23.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate bevy_ui_bms_bindings 0.23.0 into /workspace/builds/worker-7-tc2/source
[INFO] started tweaking crates.io crate bevy_ui_bms_bindings 0.23.0
[INFO] finished tweaking crates.io crate bevy_ui_bms_bindings 0.23.0
[INFO] tweaked toml for crates.io crate bevy_ui_bms_bindings 0.23.0 written to /workspace/builds/worker-7-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate bevy_ui_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_ui_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:147:12
[INFO] [stderr]     |
[INFO] [stderr] 147 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 152 | 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_ui_bms_bindings` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8
[INFO] running `Command { std: "docker" "start" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8", 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" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8", 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" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8" "/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:147:12
[INFO] [stderr]     |
[INFO] [stderr] 147 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 152 | 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_ui_bms_bindings` (manifest) generated 1 warning
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]     Checking cfg-if v1.0.5
[INFO] [stderr]    Compiling libc v0.2.190
[INFO] [stderr]    Compiling crossbeam-utils v0.8.23
[INFO] [stderr]     Checking futures-io v0.3.34
[INFO] [stderr]     Checking fastrand v2.5.0
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling equivalent v1.0.3
[INFO] [stderr]    Compiling winnow v1.0.4
[INFO] [stderr]     Checking smallvec v1.16.3
[INFO] [stderr]     Checking event-listener v5.4.2
[INFO] [stderr]    Compiling toml_datetime v1.1.2+spec-1.1.0
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]     Checking log v0.4.34
[INFO] [stderr]    Compiling thiserror v2.0.21
[INFO] [stderr]     Checking rand_core v0.10.1
[INFO] [stderr]    Compiling indexmap v2.14.2
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking spin v0.12.3
[INFO] [stderr]     Checking rand v0.10.3
[INFO] [stderr]     Checking futures-lite v2.6.1
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]     Checking event-listener-strategy v0.5.4
[INFO] [stderr]    Compiling mutants v0.0.3
[INFO] [stderr]    Compiling rustc-hash v2.1.3
[INFO] [stderr]     Checking foldhash v0.1.5
[INFO] [stderr]     Checking rustc-hash v1.1.0
[INFO] [stderr]     Checking hashbrown v0.15.5
[INFO] [stderr]     Checking disqualified v1.1.0
[INFO] [stderr]     Checking erased-serde v0.4.10
[INFO] [stderr]     Checking bevy_ptr v0.20.0
[INFO] [stderr]     Checking inventory v0.3.25
[INFO] [stderr]    Compiling slotmap v1.1.1
[INFO] [stderr]    Compiling cfg_aliases v0.2.2
[INFO] [stderr]    Compiling inotify-sys v0.1.8
[INFO] [stderr]    Compiling nix v0.31.3
[INFO] [stderr]     Checking typewit v1.15.2
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking concurrent-queue v2.5.0
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking async-channel v2.5.0
[INFO] [stderr]     Checking crossbeam-queue v0.3.14
[INFO] [stderr]    Compiling shlex v2.0.1
[INFO] [stderr]    Compiling find-msvc-tools v0.1.14
[INFO] [stderr]     Checking approx v0.5.1
[INFO] [stderr]    Compiling rustix v1.1.5
[INFO] [stderr]     Checking const_panic v0.2.17
[INFO] [stderr]     Checking either v1.19.0
[INFO] [stderr]     Checking linux-raw-sys v0.12.1
[INFO] [stderr]    Compiling cc v1.8.0
[INFO] [stderr]     Checking walkdir v2.5.0
[INFO] [stderr]     Checking crossbeam-channel v0.5.17
[INFO] [stderr]     Checking piper v0.2.5
[INFO] [stderr]     Checking async-executor v1.14.0
[INFO] [stderr]     Checking notify-types v2.1.0
[INFO] [stderr]    Compiling async-io v2.6.0
[INFO] [stderr]     Checking async-lock v3.4.2
[INFO] [stderr]     Checking file-id v0.2.3
[INFO] [stderr]     Checking unicode-ident v1.0.27
[INFO] [stderr]     Checking futures-task v0.3.34
[INFO] [stderr]     Checking blocking v1.7.0
[INFO] [stderr]     Checking stable_deref_trait v1.2.1
[INFO] [stderr]     Checking constant_time_eq v0.4.2
[INFO] [stderr]     Checking cpufeatures v0.3.1
[INFO] [stderr]     Checking stackfuture v0.3.1
[INFO] [stderr]     Checking async-broadcast v0.7.2
[INFO] [stderr]     Checking atomicow v1.2.0
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking lazy_static v1.5.1
[INFO] [stderr]     Checking tracing-log v0.2.0
[INFO] [stderr]    Compiling toml_parser v1.1.5+spec-1.1.0
[INFO] [stderr]     Checking simd-adler32 v0.3.10
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]     Checking writeable v0.6.4
[INFO] [stderr]     Checking adler2 v2.0.1
[INFO] [stderr]    Compiling crc32fast v1.5.2
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]    Compiling zerocopy v0.8.63
[INFO] [stderr]     Checking litemap v0.8.3
[INFO] [stderr]     Checking miniz_oxide v0.9.1
[INFO] [stderr]     Checking async-fs v2.2.0
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking fdeflate v0.3.7
[INFO] [stderr]     Checking pxfm v0.1.30
[INFO] [stderr]    Compiling variadics_please v2.0.0
[INFO] [stderr]     Checking euclid v0.22.14
[INFO] [stderr]     Checking twox-hash v2.1.5
[INFO] [stderr]     Checking flate2 v1.1.10
[INFO] [stderr]     Checking ruzstd v0.8.3
[INFO] [stderr]     Checking ktx2 v0.5.0
[INFO] [stderr]    Compiling icu_locale_fallback_data v2.3.0
[INFO] [stderr]    Compiling toml_edit v0.25.17+spec-1.1.0
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking mio v1.2.4
[INFO] [stderr]     Checking uuid v1.28.0
[INFO] [stderr]     Checking inotify v0.11.5
[INFO] [stderr]     Checking png v0.18.1
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]    Compiling icu_properties_data v2.3.0
[INFO] [stderr]     Checking rand_distr v0.6.0
[INFO] [stderr]    Compiling icu_normalizer_data v2.3.0
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]    Compiling icu_segmenter_data v2.3.0
[INFO] [stderr]     Checking guillotiere v0.7.0
[INFO] [stderr]     Checking notify v8.2.0
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]     Checking parlance v0.1.1
[INFO] [stderr]     Checking ctrlc v3.5.2
[INFO] [stderr]     Checking linebender_resource_handle v0.1.1
[INFO] [stderr]     Checking zeno v0.3.3
[INFO] [stderr]     Checking yazi v0.2.1
[INFO] [stderr]     Checking sys-locale v0.3.2
[INFO] [stderr]     Checking dot-writer v0.1.4
[INFO] [stderr]     Checking accesskit v0.24.1
[INFO] [stderr]     Checking taffy v0.14.0
[INFO] [stderr]     Checking notify-debouncer-full v0.7.0
[INFO] [stderr]    Compiling blake3 v1.8.7
[INFO] [stderr]     Checking matchers v0.2.0
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]     Checking moxcms v0.8.1
[INFO] [stderr]    Compiling bevy_macro_utils v0.20.0
[INFO] [stderr]    Compiling encase_derive_impl v0.12.1
[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_derive v0.20.0
[INFO] [stderr]    Compiling bevy_asset_macros v0.20.0
[INFO] [stderr]    Compiling zerocopy-derive v0.8.63
[INFO] [stderr]    Compiling profiling-procmacros v1.0.18
[INFO] [stderr]    Compiling bevy_mod_scripting_derive v0.23.0
[INFO] [stderr]    Compiling variadics_please v1.1.0
[INFO] [stderr]    Compiling synstructure v0.14.0
[INFO] [stderr]    Compiling bevy_ecs_macros v0.20.0
[INFO] [stderr]     Checking profiling v1.0.18
[INFO] [stderr]    Compiling encase_derive v0.12.1
[INFO] [stderr]    Compiling bevy_encase_derive v0.20.0
[INFO] [stderr]    Compiling bytemuck_derive v1.12.1
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]    Compiling zerofrom-derive v0.1.8
[INFO] [stderr]    Compiling yoke-derive v0.8.4
[INFO] [stderr]    Compiling futures-macro v0.3.34
[INFO] [stderr]    Compiling zerovec-derive v0.11.6
[INFO] [stderr]    Compiling displaydoc v0.2.7
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]     Checking zerofrom v0.1.8
[INFO] [stderr]     Checking yoke v0.8.3
[INFO] [stderr]     Checking zerovec v0.11.8
[INFO] [stderr]     Checking zerotrie v0.2.5
[INFO] [stderr]     Checking glam v0.33.12
[INFO] [stderr]     Checking font-types v0.12.6
[INFO] [stderr]     Checking encase v0.12.1
[INFO] [stderr]     Checking polling v3.11.0
[INFO] [stderr]     Checking read-fonts v0.41.0
[INFO] [stderr]     Checking image v0.25.10
[INFO] [stderr]     Checking tinystr v0.8.4
[INFO] [stderr]     Checking potential_utf v0.1.6
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking icu_collections v2.3.0
[INFO] [stderr]     Checking icu_locale_core v2.3.0
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking icu_provider v2.3.1
[INFO] [stderr]     Checking icu_properties v2.3.0
[INFO] [stderr]     Checking icu_locale_fallback v2.3.0
[INFO] [stderr]     Checking icu_normalizer v2.3.0
[INFO] [stderr]     Checking icu_segmenter v2.3.0
[INFO] [stderr]     Checking bevy_platform v0.20.0
[INFO] [stderr]     Checking naga-types v30.0.1
[INFO] [stderr]     Checking petgraph v0.8.3
[INFO] [stderr]     Checking smol_str v0.2.2
[INFO] [stderr]     Checking ron v0.12.2
[INFO] [stderr]     Checking bevy_utils v0.20.0
[INFO] [stderr]     Checking bevy_tasks v0.20.0
[INFO] [stderr]     Checking wgpu-types v30.0.1
[INFO] [stderr]     Checking parley_data v0.11.1
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking hexasphere v19.0.0
[INFO] [stderr]     Checking bevy_reflect v0.20.0
[INFO] [stderr]     Checking skrifa v0.44.0
[INFO] [stderr]     Checking harfrust v0.12.0
[INFO] [stderr]     Checking fontique v0.11.1
[INFO] [stderr]     Checking swash v0.2.10
[INFO] [stderr]     Checking parley v0.11.1
[INFO] [stderr]     Checking bevy_ecs v0.20.0
[INFO] [stderr]     Checking bevy_math v0.20.0
[INFO] [stderr]     Checking bevy_curve v0.20.0
[INFO] [stderr]     Checking bevy_shape v0.20.0
[INFO] [stderr]     Checking bevy_color v0.20.0
[INFO] [stderr]     Checking bevy_app v0.20.0
[INFO] [stderr]     Checking bevy_time v0.20.0
[INFO] [stderr]     Checking bevy_log v0.20.0
[INFO] [stderr]     Checking bevy_transform v0.20.0
[INFO] [stderr]     Checking bevy_input v0.20.0
[INFO] [stderr]     Checking bevy_a11y v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_world v0.23.0
[INFO] [stderr]     Checking bevy_clipboard v0.20.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_image v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_display v0.23.0
[INFO] [stderr]     Checking bevy_mesh v0.20.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_window v0.20.0
[INFO] [stderr]     Checking bevy_text v0.20.0
[INFO] [stderr]     Checking bevy_camera v0.20.0
[INFO] [stderr]     Checking bevy_picking v0.20.0
[INFO] [stderr]     Checking bevy_input_focus v0.20.0
[INFO] [stderr]     Checking bevy_sprite v0.20.0
[INFO] [stderr]     Checking bevy_ui v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_core v0.23.0
[INFO] [stderr]     Checking bevy_ui_bms_bindings v0.23.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:40:40
[INFO] [stdout]    |
[INFO] [stdout] 40 |                       let output: bool = <::bevy_ui::Display as ::std::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 41 | |                         ::bevy_ui::Display,
[INFO] [stdout] 42 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 43 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 42 -                     >>::eq(&_self, &other)
[INFO] [stdout] 43 -                     .into();
[INFO] [stdout] 42 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Display as ::std::cmp::PartialEq<
[INFO] [stdout] 41 |                         ::bevy_ui::Display,
[INFO] [stdout] 42 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:283:44
[INFO] [stdout]     |
[INFO] [stdout] 283 |                           let output: bool = <::bevy_ui::widget::Text as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 284 | |                             ::bevy_ui::widget::Text,
[INFO] [stdout] 285 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 286 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -                         >>::eq(&_self, &other)
[INFO] [stdout] 286 -                             .into();
[INFO] [stdout] 285 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::Text as ::std::cmp::PartialEq<
[INFO] [stdout] 284 |                             ::bevy_ui::widget::Text,
[INFO] [stdout] 285 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:328:40
[INFO] [stdout]     |
[INFO] [stdout] 328 |                       let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 329 | |                         ::bevy_ui::widget::TextShadow,
[INFO] [stdout] 330 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 331 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 330 -                     >>::eq(&_self, &other)
[INFO] [stdout] 331 -                     .into();
[INFO] [stdout] 330 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq<
[INFO] [stdout] 329 |                         ::bevy_ui::widget::TextShadow,
[INFO] [stdout] 330 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:531:40
[INFO] [stdout]     |
[INFO] [stdout] 531 |                       let output: bool = <::bevy_ui::widget::InlineImage as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 532 | |                         ::bevy_ui::widget::InlineImage,
[INFO] [stdout] 533 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 534 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 533 -                     >>::eq(&_self, &other)
[INFO] [stdout] 534 -                     .into();
[INFO] [stdout] 533 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 531 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::InlineImage as ::std::cmp::PartialEq<
[INFO] [stdout] 532 |                         ::bevy_ui::widget::InlineImage,
[INFO] [stdout] 533 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:628:44
[INFO] [stdout]     |
[INFO] [stdout] 628 |                           let output: bool = <::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 629 | |                             ::bevy_ui::widget::NodeImageMode,
[INFO] [stdout] 630 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 631 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 630 -                         >>::eq(&_self, &other)
[INFO] [stdout] 631 -                             .into();
[INFO] [stdout] 630 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 628 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq<
[INFO] [stdout] 629 |                             ::bevy_ui::widget::NodeImageMode,
[INFO] [stdout] 630 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:645:44
[INFO] [stdout]     |
[INFO] [stdout] 645 |                           let output: bool = ::bevy_ui::widget::NodeImageMode::uses_slices(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 646 | |                                 &_self,
[INFO] [stdout] 647 | |                             )
[INFO] [stdout] 648 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 647 -                             )
[INFO] [stdout] 648 -                             .into();
[INFO] [stdout] 647 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::widget::NodeImageMode::uses_slices(
[INFO] [stdout] 646 |                                 &_self,
[INFO] [stdout] 647 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:726:40
[INFO] [stdout]     |
[INFO] [stdout] 726 |                       let output: bool = <::bevy_ui::ComputedStackIndex as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 727 | |                         ::bevy_ui::ComputedStackIndex,
[INFO] [stdout] 728 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 729 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 728 -                     >>::eq(&_self, &other)
[INFO] [stdout] 729 -                     .into();
[INFO] [stdout] 728 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ComputedStackIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 727 |                         ::bevy_ui::ComputedStackIndex,
[INFO] [stdout] 728 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:782:25
[INFO] [stdout]     |
[INFO] [stdout] 782 | /                         <::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 783 | |                             ::bevy_ui::ComputedUiTargetCamera,
[INFO] [stdout] 784 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 785 | |                         .into();
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 784 -                         >>::eq(&_self, &other)
[INFO] [stdout] 785 -                         .into();
[INFO] [stdout] 784 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 782 ~                         <bool as Into<_>>::into(<::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 783 |                             ::bevy_ui::ComputedUiTargetCamera,
[INFO] [stdout] 784 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:831:25
[INFO] [stdout]     |
[INFO] [stdout] 831 | /                         <::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq<
[INFO] [stdout] 832 | |                             ::bevy_ui::ComputedUiRenderTargetInfo,
[INFO] [stdout] 833 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 834 | |                         .into();
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 833 -                         >>::eq(&_self, &other)
[INFO] [stdout] 834 -                         .into();
[INFO] [stdout] 833 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 831 ~                         <bool as Into<_>>::into(<::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq<
[INFO] [stdout] 832 |                             ::bevy_ui::ComputedUiRenderTargetInfo,
[INFO] [stdout] 833 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:879:25
[INFO] [stdout]     |
[INFO] [stdout] 879 |                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_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] 879 -                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self).into();
[INFO] [stdout] 879 +                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 879 -                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self).into();
[INFO] [stdout] 879 +                         <f32 as Into<_>>::into(::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:977:44
[INFO] [stdout]     |
[INFO] [stdout] 977 |                           let output: bool = ::bevy_ui::ComputedNode::contains_point(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 978 | |                                 &_self,
[INFO] [stdout] 979 | |                                 transform.into_inner(),
[INFO] [stdout] 980 | |                                 point.into_inner(),
[INFO] [stdout] 981 | |                             )
[INFO] [stdout] 982 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 981 -                             )
[INFO] [stdout] 982 -                             .into();
[INFO] [stdout] 981 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 977 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::ComputedNode::contains_point(
[INFO] [stdout] 978 |                                 &_self,
[INFO] [stdout] 979 |                                 transform.into_inner(),
[INFO] [stdout] 980 |                                 point.into_inner(),
[INFO] [stdout] 981 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1047:44
[INFO] [stdout]      |
[INFO] [stdout] 1047 |                           let output: bool = <::bevy_ui::ComputedNode as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1048 | |                             ::bevy_ui::ComputedNode,
[INFO] [stdout] 1049 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1050 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1050 -                             .into();
[INFO] [stdout] 1049 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1047 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ComputedNode as ::std::cmp::PartialEq<
[INFO] [stdout] 1048 |                             ::bevy_ui::ComputedNode,
[INFO] [stdout] 1049 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1081:43
[INFO] [stdout]      |
[INFO] [stdout] 1081 |                           let output: f32 = ::bevy_ui::ComputedNode::inverse_scale_factor(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1082 | |                                 &_self,
[INFO] [stdout] 1083 | |                             )
[INFO] [stdout] 1084 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1083 -                             )
[INFO] [stdout] 1084 -                             .into();
[INFO] [stdout] 1083 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1081 ~                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::inverse_scale_factor(
[INFO] [stdout] 1082 |                                 &_self,
[INFO] [stdout] 1083 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1098:44
[INFO] [stdout]      |
[INFO] [stdout] 1098 |                           let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1099 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1098 -                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout] 1099 -                             .into();
[INFO] [stdout] 1098 +                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1098 -                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout] 1099 -                             .into();
[INFO] [stdout] 1098 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::ComputedNode::is_empty(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1113:43
[INFO] [stdout]      |
[INFO] [stdout] 1113 |                           let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1113 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout] 1114 -                             .into();
[INFO] [stdout] 1113 +                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1113 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout] 1114 -                             .into();
[INFO] [stdout] 1113 +                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::outline_offset(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1145:43
[INFO] [stdout]      |
[INFO] [stdout] 1145 |                           let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1146 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout] 1146 -                             .into();
[INFO] [stdout] 1145 +                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout] 1146 -                             .into();
[INFO] [stdout] 1145 +                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::outline_width(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1310:40
[INFO] [stdout]      |
[INFO] [stdout] 1310 |                       let output: bool = <::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1311 | |                         ::bevy_ui::UiGlobalTransform,
[INFO] [stdout] 1312 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1313 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1312 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1313 -                     .into();
[INFO] [stdout] 1312 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1310 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq<
[INFO] [stdout] 1311 |                         ::bevy_ui::UiGlobalTransform,
[INFO] [stdout] 1312 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1451:44
[INFO] [stdout]      |
[INFO] [stdout] 1451 |   ...   let output: bool = <::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation as ::std::cmp::PartialEq<
[INFO] [stdout]      |  __________________________^
[INFO] [stdout] 1452 | | ...       ::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation,
[INFO] [stdout] 1453 | | ...   >>::eq(&_self, &other)
[INFO] [stdout] 1454 | | ...       .into();
[INFO] [stdout]      | |_________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1453 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1454 -                             .into();
[INFO] [stdout] 1453 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1451 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation as ::std::cmp::PartialEq<
[INFO] [stdout] 1452 |                             ::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation,
[INFO] [stdout] 1453 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:1480:42
[INFO] [stdout]      |
[INFO] [stdout] 1480 |                           let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 1481 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1480 -                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout] 1481 -                             .into();
[INFO] [stdout] 1480 +                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1480 -                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout] 1481 -                             .into();
[INFO] [stdout] 1480 +                         let output: () = <() as Into<_>>::into(::bevy_ui::ContentSize::clear(&mut _self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1556:44
[INFO] [stdout]      |
[INFO] [stdout] 1556 |                           let output: bool = <::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1557 | |                             ::bevy_ui::UiTargetCamera,
[INFO] [stdout] 1558 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1559 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1558 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1559 -                             .into();
[INFO] [stdout] 1558 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1556 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 1557 |                             ::bevy_ui::UiTargetCamera,
[INFO] [stdout] 1558 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1602:44
[INFO] [stdout]      |
[INFO] [stdout] 1602 |                           let output: bool = ::bevy_ui::CalculatedClip::contains_point(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1603 | |                                 &_self,
[INFO] [stdout] 1604 | |                                 point.into_inner(),
[INFO] [stdout] 1605 | |                             )
[INFO] [stdout] 1606 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                             )
[INFO] [stdout] 1606 -                             .into();
[INFO] [stdout] 1605 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1602 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::CalculatedClip::contains_point(
[INFO] [stdout] 1603 |                                 &_self,
[INFO] [stdout] 1604 |                                 point.into_inner(),
[INFO] [stdout] 1605 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1620:44
[INFO] [stdout]      |
[INFO] [stdout] 1620 |                           let output: bool = <::bevy_ui::CalculatedClip as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1621 | |                             ::bevy_ui::CalculatedClip,
[INFO] [stdout] 1622 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1623 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1622 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1623 -                             .into();
[INFO] [stdout] 1622 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1620 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::CalculatedClip as ::std::cmp::PartialEq<
[INFO] [stdout] 1621 |                             ::bevy_ui::CalculatedClip,
[INFO] [stdout] 1622 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1637:44
[INFO] [stdout]      |
[INFO] [stdout] 1637 |                           let output: bool = ::bevy_ui::CalculatedClip::is_fully_clipped(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1638 | |                                 &_self,
[INFO] [stdout] 1639 | |                             )
[INFO] [stdout] 1640 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1639 -                             )
[INFO] [stdout] 1640 -                             .into();
[INFO] [stdout] 1639 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1637 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::CalculatedClip::is_fully_clipped(
[INFO] [stdout] 1638 |                                 &_self,
[INFO] [stdout] 1639 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:1658:42
[INFO] [stdout]      |
[INFO] [stdout] 1658 |                           let output: () = ::bevy_ui::CalculatedClip::push_rect(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 1659 | |                                 &mut _self,
[INFO] [stdout] 1660 | |                                 rect.into_inner(),
[INFO] [stdout] 1661 | |                                 world_to_clip_local.into_inner(),
[INFO] [stdout] 1662 | |                             )
[INFO] [stdout] 1663 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1662 -                             )
[INFO] [stdout] 1663 -                             .into();
[INFO] [stdout] 1662 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1658 ~                         let output: () = <() as Into<_>>::into(::bevy_ui::CalculatedClip::push_rect(
[INFO] [stdout] 1659 |                                 &mut _self,
[INFO] [stdout] 1660 |                                 rect.into_inner(),
[INFO] [stdout] 1661 |                                 world_to_clip_local.into_inner(),
[INFO] [stdout] 1662 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1780:40
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                       let output: bool = <::bevy_ui::Node as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1781 | |                         ::bevy_ui::Node,
[INFO] [stdout] 1782 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1783 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1782 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1783 -                     .into();
[INFO] [stdout] 1782 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1780 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Node as ::std::cmp::PartialEq<
[INFO] [stdout] 1781 |                         ::bevy_ui::Node,
[INFO] [stdout] 1782 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1862:40
[INFO] [stdout]      |
[INFO] [stdout] 1862 |                       let output: bool = <::bevy_ui::Overflow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1863 | |                         ::bevy_ui::Overflow,
[INFO] [stdout] 1864 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1865 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1864 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1865 -                     .into();
[INFO] [stdout] 1864 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1862 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Overflow as ::std::cmp::PartialEq<
[INFO] [stdout] 1863 |                         ::bevy_ui::Overflow,
[INFO] [stdout] 1864 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1921:40
[INFO] [stdout]      |
[INFO] [stdout] 1921 |                     let output: bool = ::bevy_ui::Overflow::is_visible(&_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] 1921 -                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self).into();
[INFO] [stdout] 1921 +                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1921 -                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self).into();
[INFO] [stdout] 1921 +                     let output: bool = <bool as Into<_>>::into(::bevy_ui::Overflow::is_visible(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2046:44
[INFO] [stdout]      |
[INFO] [stdout] 2046 |                           let output: bool = <::bevy_ui::FocusPolicy as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2047 | |                             ::bevy_ui::FocusPolicy,
[INFO] [stdout] 2048 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2049 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2048 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2049 -                             .into();
[INFO] [stdout] 2048 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2046 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::FocusPolicy as ::std::cmp::PartialEq<
[INFO] [stdout] 2047 |                             ::bevy_ui::FocusPolicy,
[INFO] [stdout] 2048 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2090:44
[INFO] [stdout]      |
[INFO] [stdout] 2090 |                           let output: bool = <::bevy_ui::VisualBox as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2091 | |                             ::bevy_ui::VisualBox,
[INFO] [stdout] 2092 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2093 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2092 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2093 -                             .into();
[INFO] [stdout] 2092 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2090 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::VisualBox as ::std::cmp::PartialEq<
[INFO] [stdout] 2091 |                             ::bevy_ui::VisualBox,
[INFO] [stdout] 2092 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2176:44
[INFO] [stdout]      |
[INFO] [stdout] 2176 |                           let output: bool = <::bevy_ui::BoxSizing as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2177 | |                             ::bevy_ui::BoxSizing,
[INFO] [stdout] 2178 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2179 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2178 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2179 -                             .into();
[INFO] [stdout] 2178 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2176 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BoxSizing as ::std::cmp::PartialEq<
[INFO] [stdout] 2177 |                             ::bevy_ui::BoxSizing,
[INFO] [stdout] 2178 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2405:44
[INFO] [stdout]      |
[INFO] [stdout] 2405 |                           let output: bool = <::bevy_ui::UiPosition as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2406 | |                             ::bevy_ui::UiPosition,
[INFO] [stdout] 2407 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2408 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2407 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2408 -                             .into();
[INFO] [stdout] 2407 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2405 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 2406 |                             ::bevy_ui::UiPosition,
[INFO] [stdout] 2407 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2646:44
[INFO] [stdout]      |
[INFO] [stdout] 2646 |                           let output: bool = <::bevy_ui::Val as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2647 | |                             ::bevy_ui::Val,
[INFO] [stdout] 2648 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2649 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2648 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2649 -                             .into();
[INFO] [stdout] 2648 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2646 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::Val as ::std::cmp::PartialEq<
[INFO] [stdout] 2647 |                             ::bevy_ui::Val,
[INFO] [stdout] 2648 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2773:44
[INFO] [stdout]      |
[INFO] [stdout] 2773 |                           let output: bool = <::bevy_ui::ColorStop as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2774 | |                             ::bevy_ui::ColorStop,
[INFO] [stdout] 2775 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2776 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2775 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2776 -                             .into();
[INFO] [stdout] 2775 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2773 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ColorStop as ::std::cmp::PartialEq<
[INFO] [stdout] 2774 |                             ::bevy_ui::ColorStop,
[INFO] [stdout] 2775 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2837:44
[INFO] [stdout]      |
[INFO] [stdout] 2837 |                           let output: bool = <::bevy_ui::AngularColorStop as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2838 | |                             ::bevy_ui::AngularColorStop,
[INFO] [stdout] 2839 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2840 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2839 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2840 -                             .into();
[INFO] [stdout] 2839 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2837 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AngularColorStop as ::std::cmp::PartialEq<
[INFO] [stdout] 2838 |                             ::bevy_ui::AngularColorStop,
[INFO] [stdout] 2839 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2901:44
[INFO] [stdout]      |
[INFO] [stdout] 2901 |                           let output: bool = <::bevy_ui::LinearGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2902 | |                             ::bevy_ui::LinearGradient,
[INFO] [stdout] 2903 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2904 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2903 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2904 -                             .into();
[INFO] [stdout] 2903 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2901 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::LinearGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 2902 |                             ::bevy_ui::LinearGradient,
[INFO] [stdout] 2903 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2969:25
[INFO] [stdout]      |
[INFO] [stdout] 2969 | /                         <::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq<
[INFO] [stdout] 2970 | |                             ::bevy_ui::InterpolationColorSpace,
[INFO] [stdout] 2971 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2972 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2971 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2972 -                         .into();
[INFO] [stdout] 2971 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2969 ~                         <bool as Into<_>>::into(<::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq<
[INFO] [stdout] 2970 |                             ::bevy_ui::InterpolationColorSpace,
[INFO] [stdout] 2971 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3015:44
[INFO] [stdout]      |
[INFO] [stdout] 3015 |                           let output: bool = <::bevy_ui::RadialGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3016 | |                             ::bevy_ui::RadialGradient,
[INFO] [stdout] 3017 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3018 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3017 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3018 -                             .into();
[INFO] [stdout] 3017 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3015 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::RadialGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3016 |                             ::bevy_ui::RadialGradient,
[INFO] [stdout] 3017 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3081:40
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                       let output: bool = <::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3082 | |                         ::bevy_ui::RadialGradientShape,
[INFO] [stdout] 3083 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3084 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3083 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3084 -                     .into();
[INFO] [stdout] 3083 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq<
[INFO] [stdout] 3082 |                         ::bevy_ui::RadialGradientShape,
[INFO] [stdout] 3083 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3164:44
[INFO] [stdout]      |
[INFO] [stdout] 3164 |                           let output: bool = <::bevy_ui::ConicGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3165 | |                             ::bevy_ui::ConicGradient,
[INFO] [stdout] 3166 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3167 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3166 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3167 -                             .into();
[INFO] [stdout] 3166 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3164 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ConicGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3165 |                             ::bevy_ui::ConicGradient,
[INFO] [stdout] 3166 ~                         >>::eq(&_self, &other));
[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_ui::Gradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_ui::Gradient,
[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_ui::Gradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_ui::Gradient,
[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:3297:40
[INFO] [stdout]      |
[INFO] [stdout] 3297 |                     let output: bool = ::bevy_ui::Gradient::is_empty(&_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] 3297 -                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into();
[INFO] [stdout] 3297 +                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into();
[INFO] [stdout] 3297 +                     let output: bool = <bool as Into<_>>::into(::bevy_ui::Gradient::is_empty(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3336:40
[INFO] [stdout]      |
[INFO] [stdout] 3336 |                       let output: bool = <::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3337 | |                         ::bevy_ui::BackgroundGradient,
[INFO] [stdout] 3338 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3339 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3338 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3339 -                     .into();
[INFO] [stdout] 3338 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3336 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3337 |                         ::bevy_ui::BackgroundGradient,
[INFO] [stdout] 3338 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3382:44
[INFO] [stdout]      |
[INFO] [stdout] 3382 |                           let output: bool = <::bevy_ui::BorderGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3383 | |                             ::bevy_ui::BorderGradient,
[INFO] [stdout] 3384 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3384 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3385 -                             .into();
[INFO] [stdout] 3384 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3382 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3383 |                             ::bevy_ui::BorderGradient,
[INFO] [stdout] 3384 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3445:44
[INFO] [stdout]      |
[INFO] [stdout] 3445 |                           let output: bool = <::bevy_ui::Val2 as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3446 | |                             ::bevy_ui::Val2,
[INFO] [stdout] 3447 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3448 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3447 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3448 -                             .into();
[INFO] [stdout] 3447 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3445 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::Val2 as ::std::cmp::PartialEq<
[INFO] [stdout] 3446 |                             ::bevy_ui::Val2,
[INFO] [stdout] 3447 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3570:44
[INFO] [stdout]      |
[INFO] [stdout] 3570 |                           let output: bool = <::bevy_ui::UiTransform as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3571 | |                             ::bevy_ui::UiTransform,
[INFO] [stdout] 3572 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3573 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3572 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3573 -                             .into();
[INFO] [stdout] 3572 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3570 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiTransform as ::std::cmp::PartialEq<
[INFO] [stdout] 3571 |                             ::bevy_ui::UiTransform,
[INFO] [stdout] 3572 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3683:25
[INFO] [stdout]      |
[INFO] [stdout] 3683 | /                         <::bevy_ui::DeprecatedInteraction as ::std::cmp::PartialEq<
[INFO] [stdout] 3684 | |                             ::bevy_ui::DeprecatedInteraction,
[INFO] [stdout] 3685 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3686 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3685 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3686 -                         .into();
[INFO] [stdout] 3685 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3683 ~                         <bool as Into<_>>::into(<::bevy_ui::DeprecatedInteraction as ::std::cmp::PartialEq<
[INFO] [stdout] 3684 |                             ::bevy_ui::DeprecatedInteraction,
[INFO] [stdout] 3685 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3729:25
[INFO] [stdout]      |
[INFO] [stdout] 3729 |                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_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] 3729 -                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into();
[INFO] [stdout] 3729 +                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 -                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into();
[INFO] [stdout] 3729 +                         <bool as Into<_>>::into(::bevy_ui::RelativeCursorPosition::cursor_over(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3745:25
[INFO] [stdout]      |
[INFO] [stdout] 3745 | /                         <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 3746 | |                             ::bevy_ui::RelativeCursorPosition,
[INFO] [stdout] 3747 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3748 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3747 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3748 -                         .into();
[INFO] [stdout] 3747 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3745 ~                         <bool as Into<_>>::into(<::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 3746 |                             ::bevy_ui::RelativeCursorPosition,
[INFO] [stdout] 3747 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3843:44
[INFO] [stdout]      |
[INFO] [stdout] 3843 |                           let output: bool = <::bevy_ui::UiRect as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3844 | |                             ::bevy_ui::UiRect,
[INFO] [stdout] 3845 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3846 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3845 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3846 -                             .into();
[INFO] [stdout] 3845 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3843 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiRect as ::std::cmp::PartialEq<
[INFO] [stdout] 3844 |                             ::bevy_ui::UiRect,
[INFO] [stdout] 3845 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4142:44
[INFO] [stdout]      |
[INFO] [stdout] 4142 |                           let output: bool = <::bevy_ui::CornerRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4143 | |                             ::bevy_ui::CornerRadius,
[INFO] [stdout] 4144 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4145 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4144 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4145 -                             .into();
[INFO] [stdout] 4144 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4142 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::CornerRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4143 |                             ::bevy_ui::CornerRadius,
[INFO] [stdout] 4144 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4264:44
[INFO] [stdout]      |
[INFO] [stdout] 4264 |                           let output: bool = <::bevy_ui::LayoutConfig as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4265 | |                             ::bevy_ui::LayoutConfig,
[INFO] [stdout] 4266 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4267 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4266 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4267 -                             .into();
[INFO] [stdout] 4266 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4264 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::LayoutConfig as ::std::cmp::PartialEq<
[INFO] [stdout] 4265 |                             ::bevy_ui::LayoutConfig,
[INFO] [stdout] 4266 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4308:40
[INFO] [stdout]      |
[INFO] [stdout] 4308 |                       let output: bool = <::bevy_ui::Outline as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4309 | |                         ::bevy_ui::Outline,
[INFO] [stdout] 4310 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4311 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4310 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4311 -                     .into();
[INFO] [stdout] 4310 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4308 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Outline as ::std::cmp::PartialEq<
[INFO] [stdout] 4309 |                         ::bevy_ui::Outline,
[INFO] [stdout] 4310 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4370:44
[INFO] [stdout]      |
[INFO] [stdout] 4370 |                           let output: bool = <::bevy_ui::OverflowAxis as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4371 | |                             ::bevy_ui::OverflowAxis,
[INFO] [stdout] 4372 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4373 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4372 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4373 -                             .into();
[INFO] [stdout] 4372 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4370 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OverflowAxis as ::std::cmp::PartialEq<
[INFO] [stdout] 4371 |                             ::bevy_ui::OverflowAxis,
[INFO] [stdout] 4372 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4387:44
[INFO] [stdout]      |
[INFO] [stdout] 4387 |                           let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4388 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4387 -                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout] 4388 -                             .into();
[INFO] [stdout] 4387 +                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4387 -                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout] 4388 -                             .into();
[INFO] [stdout] 4387 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::OverflowAxis::is_visible(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4460:44
[INFO] [stdout]      |
[INFO] [stdout] 4460 |                           let output: bool = <::bevy_ui::PositionType as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4461 | |                             ::bevy_ui::PositionType,
[INFO] [stdout] 4462 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4463 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4462 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4463 -                             .into();
[INFO] [stdout] 4462 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4460 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::PositionType as ::std::cmp::PartialEq<
[INFO] [stdout] 4461 |                             ::bevy_ui::PositionType,
[INFO] [stdout] 4462 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4506:44
[INFO] [stdout]      |
[INFO] [stdout] 4506 |                           let output: bool = <::bevy_ui::AlignSelf as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4507 | |                             ::bevy_ui::AlignSelf,
[INFO] [stdout] 4508 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4509 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4508 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4509 -                             .into();
[INFO] [stdout] 4508 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4506 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignSelf as ::std::cmp::PartialEq<
[INFO] [stdout] 4507 |                             ::bevy_ui::AlignSelf,
[INFO] [stdout] 4508 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4523:44
[INFO] [stdout]      |
[INFO] [stdout] 4523 |                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_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] 4523 -                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self).into();
[INFO] [stdout] 4523 +                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4523 -                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self).into();
[INFO] [stdout] 4523 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignSelf::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4578:40
[INFO] [stdout]      |
[INFO] [stdout] 4578 |                       let output: bool = <::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4579 | |                         ::bevy_ui::RepeatedGridTrack,
[INFO] [stdout] 4580 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4581 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4580 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4581 -                     .into();
[INFO] [stdout] 4580 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4578 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq<
[INFO] [stdout] 4579 |                         ::bevy_ui::RepeatedGridTrack,
[INFO] [stdout] 4580 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4624:44
[INFO] [stdout]      |
[INFO] [stdout] 4624 |                           let output: bool = <::bevy_ui::AlignContent as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4625 | |                             ::bevy_ui::AlignContent,
[INFO] [stdout] 4626 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4627 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4626 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4627 -                             .into();
[INFO] [stdout] 4626 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4624 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignContent as ::std::cmp::PartialEq<
[INFO] [stdout] 4625 |                             ::bevy_ui::AlignContent,
[INFO] [stdout] 4626 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4641:44
[INFO] [stdout]      |
[INFO] [stdout] 4641 |                           let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4642 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4641 -                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout] 4642 -                             .into();
[INFO] [stdout] 4641 +                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4641 -                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout] 4642 -                             .into();
[INFO] [stdout] 4641 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignContent::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4701:40
[INFO] [stdout]      |
[INFO] [stdout] 4701 |                       let output: bool = <::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4702 | |                         ::bevy_ui::ResolvedBorderRadius,
[INFO] [stdout] 4703 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4704 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4703 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4704 -                     .into();
[INFO] [stdout] 4703 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4701 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4702 |                         ::bevy_ui::ResolvedBorderRadius,
[INFO] [stdout] 4703 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4747:44
[INFO] [stdout]      |
[INFO] [stdout] 4747 |                           let output: bool = <::bevy_ui::BorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4748 | |                             ::bevy_ui::BorderRadius,
[INFO] [stdout] 4749 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4750 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4749 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4750 -                             .into();
[INFO] [stdout] 4749 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4747 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4748 |                             ::bevy_ui::BorderRadius,
[INFO] [stdout] 4749 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4869:44
[INFO] [stdout]      |
[INFO] [stdout] 4869 |                           let output: bool = <::bevy_ui::AlignItems as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4870 | |                             ::bevy_ui::AlignItems,
[INFO] [stdout] 4871 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4872 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4871 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4872 -                             .into();
[INFO] [stdout] 4871 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4869 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignItems as ::std::cmp::PartialEq<
[INFO] [stdout] 4870 |                             ::bevy_ui::AlignItems,
[INFO] [stdout] 4871 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4886:44
[INFO] [stdout]      |
[INFO] [stdout] 4886 |                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_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] 4886 -                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self).into();
[INFO] [stdout] 4886 +                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4886 -                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self).into();
[INFO] [stdout] 4886 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignItems::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4944:44
[INFO] [stdout]      |
[INFO] [stdout] 4944 |                           let output: bool = <::bevy_ui::FlexDirection as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4945 | |                             ::bevy_ui::FlexDirection,
[INFO] [stdout] 4946 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4947 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4946 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4947 -                             .into();
[INFO] [stdout] 4946 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4944 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::FlexDirection as ::std::cmp::PartialEq<
[INFO] [stdout] 4945 |                             ::bevy_ui::FlexDirection,
[INFO] [stdout] 4946 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4988:40
[INFO] [stdout]      |
[INFO] [stdout] 4988 |                       let output: bool = <::bevy_ui::FlexWrap as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4989 | |                         ::bevy_ui::FlexWrap,
[INFO] [stdout] 4990 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4991 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4990 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4991 -                     .into();
[INFO] [stdout] 4990 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4988 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::FlexWrap as ::std::cmp::PartialEq<
[INFO] [stdout] 4989 |                         ::bevy_ui::FlexWrap,
[INFO] [stdout] 4990 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5031:44
[INFO] [stdout]      |
[INFO] [stdout] 5031 |                           let output: bool = <::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5032 | |                             ::bevy_ui::GridAutoFlow,
[INFO] [stdout] 5033 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5034 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5033 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5034 -                             .into();
[INFO] [stdout] 5033 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5031 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq<
[INFO] [stdout] 5032 |                             ::bevy_ui::GridAutoFlow,
[INFO] [stdout] 5033 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5127:44
[INFO] [stdout]      |
[INFO] [stdout] 5127 |                           let output: bool = <::bevy_ui::GridPlacement as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5128 | |                             ::bevy_ui::GridPlacement,
[INFO] [stdout] 5129 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5130 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5129 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5130 -                             .into();
[INFO] [stdout] 5129 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5127 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridPlacement as ::std::cmp::PartialEq<
[INFO] [stdout] 5128 |                             ::bevy_ui::GridPlacement,
[INFO] [stdout] 5129 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<i16>`
[INFO] [stdout]     --> src/lib.rs:5144:66
[INFO] [stdout]      |
[INFO] [stdout] 5144 |                           let output: ::std::option::Option<i16> = ::bevy_ui::GridPlacement::get_end(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5145 | |                                 _self.into_inner(),
[INFO] [stdout] 5146 | |                             )
[INFO] [stdout] 5147 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5146 -                             )
[INFO] [stdout] 5147 -                             .into();
[INFO] [stdout] 5146 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5144 ~                         let output: ::std::option::Option<i16> = <std::option::Option<i16> as Into<_>>::into(::bevy_ui::GridPlacement::get_end(
[INFO] [stdout] 5145 |                                 _self.into_inner(),
[INFO] [stdout] 5146 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]     --> src/lib.rs:5161:66
[INFO] [stdout]      |
[INFO] [stdout] 5161 |                           let output: ::std::option::Option<u16> = ::bevy_ui::GridPlacement::get_span(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5162 | |                                 _self.into_inner(),
[INFO] [stdout] 5163 | |                             )
[INFO] [stdout] 5164 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5163 -                             )
[INFO] [stdout] 5164 -                             .into();
[INFO] [stdout] 5163 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5161 ~                         let output: ::std::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::bevy_ui::GridPlacement::get_span(
[INFO] [stdout] 5162 |                                 _self.into_inner(),
[INFO] [stdout] 5163 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<i16>`
[INFO] [stdout]     --> src/lib.rs:5178:66
[INFO] [stdout]      |
[INFO] [stdout] 5178 |                           let output: ::std::option::Option<i16> = ::bevy_ui::GridPlacement::get_start(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5179 | |                                 _self.into_inner(),
[INFO] [stdout] 5180 | |                             )
[INFO] [stdout] 5181 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5180 -                             )
[INFO] [stdout] 5181 -                             .into();
[INFO] [stdout] 5180 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5178 ~                         let output: ::std::option::Option<i16> = <std::option::Option<i16> as Into<_>>::into(::bevy_ui::GridPlacement::get_start(
[INFO] [stdout] 5179 |                                 _self.into_inner(),
[INFO] [stdout] 5180 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5348:44
[INFO] [stdout]      |
[INFO] [stdout] 5348 |                           let output: bool = <::bevy_ui::GridTrack as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5349 | |                             ::bevy_ui::GridTrack,
[INFO] [stdout] 5350 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5351 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5350 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5351 -                             .into();
[INFO] [stdout] 5350 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5348 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridTrack as ::std::cmp::PartialEq<
[INFO] [stdout] 5349 |                             ::bevy_ui::GridTrack,
[INFO] [stdout] 5350 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5390:40
[INFO] [stdout]      |
[INFO] [stdout] 5390 |                       let output: bool = <::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 5391 | |                         ::bevy_ui::GridTrackRepetition,
[INFO] [stdout] 5392 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 5393 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5392 -                     >>::eq(&_self, &other)
[INFO] [stdout] 5393 -                     .into();
[INFO] [stdout] 5392 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5390 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq<
[INFO] [stdout] 5391 |                         ::bevy_ui::GridTrackRepetition,
[INFO] [stdout] 5392 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5436:44
[INFO] [stdout]      |
[INFO] [stdout] 5436 |                           let output: bool = <::bevy_ui::InlineDirection as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5437 | |                             ::bevy_ui::InlineDirection,
[INFO] [stdout] 5438 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5439 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5438 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5439 -                             .into();
[INFO] [stdout] 5438 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5436 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::InlineDirection as ::std::cmp::PartialEq<
[INFO] [stdout] 5437 |                             ::bevy_ui::InlineDirection,
[INFO] [stdout] 5438 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5482:44
[INFO] [stdout]      |
[INFO] [stdout] 5482 |                           let output: bool = <::bevy_ui::JustifyContent as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5483 | |                             ::bevy_ui::JustifyContent,
[INFO] [stdout] 5484 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5485 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5484 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5485 -                             .into();
[INFO] [stdout] 5484 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5482 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifyContent as ::std::cmp::PartialEq<
[INFO] [stdout] 5483 |                             ::bevy_ui::JustifyContent,
[INFO] [stdout] 5484 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5499:44
[INFO] [stdout]      |
[INFO] [stdout] 5499 |                           let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5500 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5499 -                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout] 5500 -                             .into();
[INFO] [stdout] 5499 +                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5499 -                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout] 5500 -                             .into();
[INFO] [stdout] 5499 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifyContent::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5560:44
[INFO] [stdout]      |
[INFO] [stdout] 5560 |                           let output: bool = <::bevy_ui::JustifyItems as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5561 | |                             ::bevy_ui::JustifyItems,
[INFO] [stdout] 5562 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5563 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5562 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5563 -                             .into();
[INFO] [stdout] 5562 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5560 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifyItems as ::std::cmp::PartialEq<
[INFO] [stdout] 5561 |                             ::bevy_ui::JustifyItems,
[INFO] [stdout] 5562 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5577:44
[INFO] [stdout]      |
[INFO] [stdout] 5577 |                           let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5578 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5577 -                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout] 5578 -                             .into();
[INFO] [stdout] 5577 +                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5577 -                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout] 5578 -                             .into();
[INFO] [stdout] 5577 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifyItems::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5638:44
[INFO] [stdout]      |
[INFO] [stdout] 5638 |                           let output: bool = <::bevy_ui::JustifySelf as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5639 | |                             ::bevy_ui::JustifySelf,
[INFO] [stdout] 5640 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5641 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5640 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5641 -                             .into();
[INFO] [stdout] 5640 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5638 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifySelf as ::std::cmp::PartialEq<
[INFO] [stdout] 5639 |                             ::bevy_ui::JustifySelf,
[INFO] [stdout] 5640 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5655:44
[INFO] [stdout]      |
[INFO] [stdout] 5655 |                           let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5656 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5655 -                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout] 5656 -                             .into();
[INFO] [stdout] 5655 +                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5655 -                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout] 5656 -                             .into();
[INFO] [stdout] 5655 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifySelf::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5715:25
[INFO] [stdout]      |
[INFO] [stdout] 5715 | /                         <::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5716 | |                             ::bevy_ui::MaxTrackSizingFunction,
[INFO] [stdout] 5717 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5718 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5717 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5718 -                         .into();
[INFO] [stdout] 5717 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5715 ~                         <bool as Into<_>>::into(<::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5716 |                             ::bevy_ui::MaxTrackSizingFunction,
[INFO] [stdout] 5717 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5762:25
[INFO] [stdout]      |
[INFO] [stdout] 5762 | /                         <::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5763 | |                             ::bevy_ui::MinTrackSizingFunction,
[INFO] [stdout] 5764 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5765 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5764 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5765 -                         .into();
[INFO] [stdout] 5764 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5762 ~                         <bool as Into<_>>::into(<::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5763 |                             ::bevy_ui::MinTrackSizingFunction,
[INFO] [stdout] 5764 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5841:44
[INFO] [stdout]      |
[INFO] [stdout] 5841 |                           let output: bool = <::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5842 | |                             ::bevy_ui::OverflowClipMargin,
[INFO] [stdout] 5843 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5844 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5843 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5844 -                             .into();
[INFO] [stdout] 5843 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5841 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq<
[INFO] [stdout] 5842 |                             ::bevy_ui::OverflowClipMargin,
[INFO] [stdout] 5843 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5920:44
[INFO] [stdout]      |
[INFO] [stdout] 5920 |                           let output: bool = <::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5921 | |                             ::bevy_ui::GlobalZIndex,
[INFO] [stdout] 5922 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5923 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5922 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5923 -                             .into();
[INFO] [stdout] 5922 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5920 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 5921 |                             ::bevy_ui::GlobalZIndex,
[INFO] [stdout] 5922 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5964:40
[INFO] [stdout]      |
[INFO] [stdout] 5964 |                       let output: bool = <::bevy_ui::ZIndex as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 5965 | |                         ::bevy_ui::ZIndex,
[INFO] [stdout] 5966 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 5967 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5966 -                     >>::eq(&_self, &other)
[INFO] [stdout] 5967 -                     .into();
[INFO] [stdout] 5966 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5964 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ZIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 5965 |                         ::bevy_ui::ZIndex,
[INFO] [stdout] 5966 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6007:44
[INFO] [stdout]      |
[INFO] [stdout] 6007 |                           let output: bool = <::bevy_ui::BackgroundColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6008 | |                             ::bevy_ui::BackgroundColor,
[INFO] [stdout] 6009 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6010 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6009 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6010 -                             .into();
[INFO] [stdout] 6009 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6007 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BackgroundColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6008 |                             ::bevy_ui::BackgroundColor,
[INFO] [stdout] 6009 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6053:44
[INFO] [stdout]      |
[INFO] [stdout] 6053 |                           let output: bool = <::bevy_ui::BorderColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6054 | |                             ::bevy_ui::BorderColor,
[INFO] [stdout] 6055 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6056 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6055 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6056 -                             .into();
[INFO] [stdout] 6055 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6053 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6054 |                             ::bevy_ui::BorderColor,
[INFO] [stdout] 6055 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6070:44
[INFO] [stdout]      |
[INFO] [stdout] 6070 |                           let output: bool = ::bevy_ui::BorderColor::is_fully_transparent(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6071 | |                                 &_self,
[INFO] [stdout] 6072 | |                             )
[INFO] [stdout] 6073 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6072 -                             )
[INFO] [stdout] 6073 -                             .into();
[INFO] [stdout] 6072 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6070 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::BorderColor::is_fully_transparent(
[INFO] [stdout] 6071 |                                 &_self,
[INFO] [stdout] 6072 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6113:40
[INFO] [stdout]      |
[INFO] [stdout] 6113 |                       let output: bool = <::bevy_ui::CalculatedClipRect as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 6114 | |                         ::bevy_ui::CalculatedClipRect,
[INFO] [stdout] 6115 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 6116 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6115 -                     >>::eq(&_self, &other)
[INFO] [stdout] 6116 -                     .into();
[INFO] [stdout] 6115 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6113 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::CalculatedClipRect as ::std::cmp::PartialEq<
[INFO] [stdout] 6114 |                         ::bevy_ui::CalculatedClipRect,
[INFO] [stdout] 6115 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6159:44
[INFO] [stdout]      |
[INFO] [stdout] 6159 |                           let output: bool = <::bevy_ui::OuterColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6160 | |                             ::bevy_ui::OuterColor,
[INFO] [stdout] 6161 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6162 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6161 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6162 -                             .into();
[INFO] [stdout] 6161 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6159 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OuterColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6160 |                             ::bevy_ui::OuterColor,
[INFO] [stdout] 6161 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6203:44
[INFO] [stdout]      |
[INFO] [stdout] 6203 |                           let output: bool = <::bevy_ui::BoxShadow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6204 | |                             ::bevy_ui::BoxShadow,
[INFO] [stdout] 6205 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6206 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6205 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6206 -                             .into();
[INFO] [stdout] 6205 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6203 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BoxShadow as ::std::cmp::PartialEq<
[INFO] [stdout] 6204 |                             ::bevy_ui::BoxShadow,
[INFO] [stdout] 6205 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6273:44
[INFO] [stdout]      |
[INFO] [stdout] 6273 |                           let output: bool = <::bevy_ui::ShadowStyle as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6274 | |                             ::bevy_ui::ShadowStyle,
[INFO] [stdout] 6275 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6276 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6275 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6276 -                             .into();
[INFO] [stdout] 6275 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6273 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ShadowStyle as ::std::cmp::PartialEq<
[INFO] [stdout] 6274 |                             ::bevy_ui::ShadowStyle,
[INFO] [stdout] 6275 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `bevy_ui_bms_bindings` (lib) due to 92 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:40:40
[INFO] [stdout]    |
[INFO] [stdout] 40 |                       let output: bool = <::bevy_ui::Display as ::std::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 41 | |                         ::bevy_ui::Display,
[INFO] [stdout] 42 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 43 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 42 -                     >>::eq(&_self, &other)
[INFO] [stdout] 43 -                     .into();
[INFO] [stdout] 42 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Display as ::std::cmp::PartialEq<
[INFO] [stdout] 41 |                         ::bevy_ui::Display,
[INFO] [stdout] 42 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:283:44
[INFO] [stdout]     |
[INFO] [stdout] 283 |                           let output: bool = <::bevy_ui::widget::Text as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 284 | |                             ::bevy_ui::widget::Text,
[INFO] [stdout] 285 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 286 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -                         >>::eq(&_self, &other)
[INFO] [stdout] 286 -                             .into();
[INFO] [stdout] 285 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::Text as ::std::cmp::PartialEq<
[INFO] [stdout] 284 |                             ::bevy_ui::widget::Text,
[INFO] [stdout] 285 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:328:40
[INFO] [stdout]     |
[INFO] [stdout] 328 |                       let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 329 | |                         ::bevy_ui::widget::TextShadow,
[INFO] [stdout] 330 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 331 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 330 -                     >>::eq(&_self, &other)
[INFO] [stdout] 331 -                     .into();
[INFO] [stdout] 330 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq<
[INFO] [stdout] 329 |                         ::bevy_ui::widget::TextShadow,
[INFO] [stdout] 330 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:531:40
[INFO] [stdout]     |
[INFO] [stdout] 531 |                       let output: bool = <::bevy_ui::widget::InlineImage as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 532 | |                         ::bevy_ui::widget::InlineImage,
[INFO] [stdout] 533 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 534 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 533 -                     >>::eq(&_self, &other)
[INFO] [stdout] 534 -                     .into();
[INFO] [stdout] 533 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 531 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::InlineImage as ::std::cmp::PartialEq<
[INFO] [stdout] 532 |                         ::bevy_ui::widget::InlineImage,
[INFO] [stdout] 533 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:628:44
[INFO] [stdout]     |
[INFO] [stdout] 628 |                           let output: bool = <::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 629 | |                             ::bevy_ui::widget::NodeImageMode,
[INFO] [stdout] 630 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 631 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 630 -                         >>::eq(&_self, &other)
[INFO] [stdout] 631 -                             .into();
[INFO] [stdout] 630 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 628 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq<
[INFO] [stdout] 629 |                             ::bevy_ui::widget::NodeImageMode,
[INFO] [stdout] 630 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:645:44
[INFO] [stdout]     |
[INFO] [stdout] 645 |                           let output: bool = ::bevy_ui::widget::NodeImageMode::uses_slices(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 646 | |                                 &_self,
[INFO] [stdout] 647 | |                             )
[INFO] [stdout] 648 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 647 -                             )
[INFO] [stdout] 648 -                             .into();
[INFO] [stdout] 647 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::widget::NodeImageMode::uses_slices(
[INFO] [stdout] 646 |                                 &_self,
[INFO] [stdout] 647 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:726:40
[INFO] [stdout]     |
[INFO] [stdout] 726 |                       let output: bool = <::bevy_ui::ComputedStackIndex as ::std::cmp::PartialEq<
[INFO] [stdout]     |  ________________________________________^
[INFO] [stdout] 727 | |                         ::bevy_ui::ComputedStackIndex,
[INFO] [stdout] 728 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 729 | |                     .into();
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 728 -                     >>::eq(&_self, &other)
[INFO] [stdout] 729 -                     .into();
[INFO] [stdout] 728 +                     >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ComputedStackIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 727 |                         ::bevy_ui::ComputedStackIndex,
[INFO] [stdout] 728 ~                     >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:782:25
[INFO] [stdout]     |
[INFO] [stdout] 782 | /                         <::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 783 | |                             ::bevy_ui::ComputedUiTargetCamera,
[INFO] [stdout] 784 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 785 | |                         .into();
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 784 -                         >>::eq(&_self, &other)
[INFO] [stdout] 785 -                         .into();
[INFO] [stdout] 784 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 782 ~                         <bool as Into<_>>::into(<::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 783 |                             ::bevy_ui::ComputedUiTargetCamera,
[INFO] [stdout] 784 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:831:25
[INFO] [stdout]     |
[INFO] [stdout] 831 | /                         <::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq<
[INFO] [stdout] 832 | |                             ::bevy_ui::ComputedUiRenderTargetInfo,
[INFO] [stdout] 833 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 834 | |                         .into();
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 833 -                         >>::eq(&_self, &other)
[INFO] [stdout] 834 -                         .into();
[INFO] [stdout] 833 +                         >>::eq(&_self, &other);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 831 ~                         <bool as Into<_>>::into(<::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq<
[INFO] [stdout] 832 |                             ::bevy_ui::ComputedUiRenderTargetInfo,
[INFO] [stdout] 833 ~                         >>::eq(&_self, &other));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:879:25
[INFO] [stdout]     |
[INFO] [stdout] 879 |                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_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] 879 -                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self).into();
[INFO] [stdout] 879 +                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 879 -                         ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self).into();
[INFO] [stdout] 879 +                         <f32 as Into<_>>::into(::bevy_ui::ComputedUiRenderTargetInfo::scale_factor(&_self));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:977:44
[INFO] [stdout]     |
[INFO] [stdout] 977 |                           let output: bool = ::bevy_ui::ComputedNode::contains_point(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 978 | |                                 &_self,
[INFO] [stdout] 979 | |                                 transform.into_inner(),
[INFO] [stdout] 980 | |                                 point.into_inner(),
[INFO] [stdout] 981 | |                             )
[INFO] [stdout] 982 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 981 -                             )
[INFO] [stdout] 982 -                             .into();
[INFO] [stdout] 981 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 977 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::ComputedNode::contains_point(
[INFO] [stdout] 978 |                                 &_self,
[INFO] [stdout] 979 |                                 transform.into_inner(),
[INFO] [stdout] 980 |                                 point.into_inner(),
[INFO] [stdout] 981 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1047:44
[INFO] [stdout]      |
[INFO] [stdout] 1047 |                           let output: bool = <::bevy_ui::ComputedNode as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1048 | |                             ::bevy_ui::ComputedNode,
[INFO] [stdout] 1049 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1050 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1050 -                             .into();
[INFO] [stdout] 1049 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1047 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ComputedNode as ::std::cmp::PartialEq<
[INFO] [stdout] 1048 |                             ::bevy_ui::ComputedNode,
[INFO] [stdout] 1049 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1081:43
[INFO] [stdout]      |
[INFO] [stdout] 1081 |                           let output: f32 = ::bevy_ui::ComputedNode::inverse_scale_factor(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1082 | |                                 &_self,
[INFO] [stdout] 1083 | |                             )
[INFO] [stdout] 1084 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1083 -                             )
[INFO] [stdout] 1084 -                             .into();
[INFO] [stdout] 1083 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1081 ~                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::inverse_scale_factor(
[INFO] [stdout] 1082 |                                 &_self,
[INFO] [stdout] 1083 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1098:44
[INFO] [stdout]      |
[INFO] [stdout] 1098 |                           let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1099 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1098 -                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout] 1099 -                             .into();
[INFO] [stdout] 1098 +                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1098 -                         let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self)
[INFO] [stdout] 1099 -                             .into();
[INFO] [stdout] 1098 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::ComputedNode::is_empty(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1113:43
[INFO] [stdout]      |
[INFO] [stdout] 1113 |                           let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1113 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout] 1114 -                             .into();
[INFO] [stdout] 1113 +                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1113 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self)
[INFO] [stdout] 1114 -                             .into();
[INFO] [stdout] 1113 +                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::outline_offset(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1145:43
[INFO] [stdout]      |
[INFO] [stdout] 1145 |                           let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1146 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout] 1146 -                             .into();
[INFO] [stdout] 1145 +                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                         let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self)
[INFO] [stdout] 1146 -                             .into();
[INFO] [stdout] 1145 +                         let output: f32 = <f32 as Into<_>>::into(::bevy_ui::ComputedNode::outline_width(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1310:40
[INFO] [stdout]      |
[INFO] [stdout] 1310 |                       let output: bool = <::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1311 | |                         ::bevy_ui::UiGlobalTransform,
[INFO] [stdout] 1312 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1313 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1312 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1313 -                     .into();
[INFO] [stdout] 1312 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1310 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq<
[INFO] [stdout] 1311 |                         ::bevy_ui::UiGlobalTransform,
[INFO] [stdout] 1312 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1451:44
[INFO] [stdout]      |
[INFO] [stdout] 1451 |   ...   let output: bool = <::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation as ::std::cmp::PartialEq<
[INFO] [stdout]      |  __________________________^
[INFO] [stdout] 1452 | | ...       ::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation,
[INFO] [stdout] 1453 | | ...   >>::eq(&_self, &other)
[INFO] [stdout] 1454 | | ...       .into();
[INFO] [stdout]      | |_________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1453 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1454 -                             .into();
[INFO] [stdout] 1453 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1451 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation as ::std::cmp::PartialEq<
[INFO] [stdout] 1452 |                             ::bevy_ui::auto_directional_navigation::AutoDirectionalNavigation,
[INFO] [stdout] 1453 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:1480:42
[INFO] [stdout]      |
[INFO] [stdout] 1480 |                           let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 1481 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1480 -                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout] 1481 -                             .into();
[INFO] [stdout] 1480 +                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1480 -                         let output: () = ::bevy_ui::ContentSize::clear(&mut _self)
[INFO] [stdout] 1481 -                             .into();
[INFO] [stdout] 1480 +                         let output: () = <() as Into<_>>::into(::bevy_ui::ContentSize::clear(&mut _self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1556:44
[INFO] [stdout]      |
[INFO] [stdout] 1556 |                           let output: bool = <::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1557 | |                             ::bevy_ui::UiTargetCamera,
[INFO] [stdout] 1558 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1559 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1558 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1559 -                             .into();
[INFO] [stdout] 1558 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1556 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq<
[INFO] [stdout] 1557 |                             ::bevy_ui::UiTargetCamera,
[INFO] [stdout] 1558 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1602:44
[INFO] [stdout]      |
[INFO] [stdout] 1602 |                           let output: bool = ::bevy_ui::CalculatedClip::contains_point(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1603 | |                                 &_self,
[INFO] [stdout] 1604 | |                                 point.into_inner(),
[INFO] [stdout] 1605 | |                             )
[INFO] [stdout] 1606 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                             )
[INFO] [stdout] 1606 -                             .into();
[INFO] [stdout] 1605 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1602 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::CalculatedClip::contains_point(
[INFO] [stdout] 1603 |                                 &_self,
[INFO] [stdout] 1604 |                                 point.into_inner(),
[INFO] [stdout] 1605 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1620:44
[INFO] [stdout]      |
[INFO] [stdout] 1620 |                           let output: bool = <::bevy_ui::CalculatedClip as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1621 | |                             ::bevy_ui::CalculatedClip,
[INFO] [stdout] 1622 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1623 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1622 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1623 -                             .into();
[INFO] [stdout] 1622 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1620 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::CalculatedClip as ::std::cmp::PartialEq<
[INFO] [stdout] 1621 |                             ::bevy_ui::CalculatedClip,
[INFO] [stdout] 1622 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1637:44
[INFO] [stdout]      |
[INFO] [stdout] 1637 |                           let output: bool = ::bevy_ui::CalculatedClip::is_fully_clipped(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1638 | |                                 &_self,
[INFO] [stdout] 1639 | |                             )
[INFO] [stdout] 1640 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1639 -                             )
[INFO] [stdout] 1640 -                             .into();
[INFO] [stdout] 1639 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1637 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::CalculatedClip::is_fully_clipped(
[INFO] [stdout] 1638 |                                 &_self,
[INFO] [stdout] 1639 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:1658:42
[INFO] [stdout]      |
[INFO] [stdout] 1658 |                           let output: () = ::bevy_ui::CalculatedClip::push_rect(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 1659 | |                                 &mut _self,
[INFO] [stdout] 1660 | |                                 rect.into_inner(),
[INFO] [stdout] 1661 | |                                 world_to_clip_local.into_inner(),
[INFO] [stdout] 1662 | |                             )
[INFO] [stdout] 1663 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1662 -                             )
[INFO] [stdout] 1663 -                             .into();
[INFO] [stdout] 1662 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1658 ~                         let output: () = <() as Into<_>>::into(::bevy_ui::CalculatedClip::push_rect(
[INFO] [stdout] 1659 |                                 &mut _self,
[INFO] [stdout] 1660 |                                 rect.into_inner(),
[INFO] [stdout] 1661 |                                 world_to_clip_local.into_inner(),
[INFO] [stdout] 1662 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1780:40
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                       let output: bool = <::bevy_ui::Node as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1781 | |                         ::bevy_ui::Node,
[INFO] [stdout] 1782 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1783 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1782 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1783 -                     .into();
[INFO] [stdout] 1782 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1780 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Node as ::std::cmp::PartialEq<
[INFO] [stdout] 1781 |                         ::bevy_ui::Node,
[INFO] [stdout] 1782 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1862:40
[INFO] [stdout]      |
[INFO] [stdout] 1862 |                       let output: bool = <::bevy_ui::Overflow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 1863 | |                         ::bevy_ui::Overflow,
[INFO] [stdout] 1864 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 1865 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1864 -                     >>::eq(&_self, &other)
[INFO] [stdout] 1865 -                     .into();
[INFO] [stdout] 1864 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1862 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Overflow as ::std::cmp::PartialEq<
[INFO] [stdout] 1863 |                         ::bevy_ui::Overflow,
[INFO] [stdout] 1864 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1921:40
[INFO] [stdout]      |
[INFO] [stdout] 1921 |                     let output: bool = ::bevy_ui::Overflow::is_visible(&_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] 1921 -                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self).into();
[INFO] [stdout] 1921 +                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1921 -                     let output: bool = ::bevy_ui::Overflow::is_visible(&_self).into();
[INFO] [stdout] 1921 +                     let output: bool = <bool as Into<_>>::into(::bevy_ui::Overflow::is_visible(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2046:44
[INFO] [stdout]      |
[INFO] [stdout] 2046 |                           let output: bool = <::bevy_ui::FocusPolicy as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2047 | |                             ::bevy_ui::FocusPolicy,
[INFO] [stdout] 2048 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2049 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2048 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2049 -                             .into();
[INFO] [stdout] 2048 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2046 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::FocusPolicy as ::std::cmp::PartialEq<
[INFO] [stdout] 2047 |                             ::bevy_ui::FocusPolicy,
[INFO] [stdout] 2048 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2090:44
[INFO] [stdout]      |
[INFO] [stdout] 2090 |                           let output: bool = <::bevy_ui::VisualBox as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2091 | |                             ::bevy_ui::VisualBox,
[INFO] [stdout] 2092 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2093 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2092 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2093 -                             .into();
[INFO] [stdout] 2092 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2090 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::VisualBox as ::std::cmp::PartialEq<
[INFO] [stdout] 2091 |                             ::bevy_ui::VisualBox,
[INFO] [stdout] 2092 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2176:44
[INFO] [stdout]      |
[INFO] [stdout] 2176 |                           let output: bool = <::bevy_ui::BoxSizing as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2177 | |                             ::bevy_ui::BoxSizing,
[INFO] [stdout] 2178 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2179 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2178 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2179 -                             .into();
[INFO] [stdout] 2178 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2176 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BoxSizing as ::std::cmp::PartialEq<
[INFO] [stdout] 2177 |                             ::bevy_ui::BoxSizing,
[INFO] [stdout] 2178 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2405:44
[INFO] [stdout]      |
[INFO] [stdout] 2405 |                           let output: bool = <::bevy_ui::UiPosition as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2406 | |                             ::bevy_ui::UiPosition,
[INFO] [stdout] 2407 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2408 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2407 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2408 -                             .into();
[INFO] [stdout] 2407 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2405 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 2406 |                             ::bevy_ui::UiPosition,
[INFO] [stdout] 2407 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2646:44
[INFO] [stdout]      |
[INFO] [stdout] 2646 |                           let output: bool = <::bevy_ui::Val as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2647 | |                             ::bevy_ui::Val,
[INFO] [stdout] 2648 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2649 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2648 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2649 -                             .into();
[INFO] [stdout] 2648 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2646 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::Val as ::std::cmp::PartialEq<
[INFO] [stdout] 2647 |                             ::bevy_ui::Val,
[INFO] [stdout] 2648 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2773:44
[INFO] [stdout]      |
[INFO] [stdout] 2773 |                           let output: bool = <::bevy_ui::ColorStop as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2774 | |                             ::bevy_ui::ColorStop,
[INFO] [stdout] 2775 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2776 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2775 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2776 -                             .into();
[INFO] [stdout] 2775 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2773 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ColorStop as ::std::cmp::PartialEq<
[INFO] [stdout] 2774 |                             ::bevy_ui::ColorStop,
[INFO] [stdout] 2775 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2837:44
[INFO] [stdout]      |
[INFO] [stdout] 2837 |                           let output: bool = <::bevy_ui::AngularColorStop as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2838 | |                             ::bevy_ui::AngularColorStop,
[INFO] [stdout] 2839 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2840 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2839 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2840 -                             .into();
[INFO] [stdout] 2839 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2837 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AngularColorStop as ::std::cmp::PartialEq<
[INFO] [stdout] 2838 |                             ::bevy_ui::AngularColorStop,
[INFO] [stdout] 2839 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2901:44
[INFO] [stdout]      |
[INFO] [stdout] 2901 |                           let output: bool = <::bevy_ui::LinearGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2902 | |                             ::bevy_ui::LinearGradient,
[INFO] [stdout] 2903 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2904 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2903 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2904 -                             .into();
[INFO] [stdout] 2903 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2901 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::LinearGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 2902 |                             ::bevy_ui::LinearGradient,
[INFO] [stdout] 2903 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2969:25
[INFO] [stdout]      |
[INFO] [stdout] 2969 | /                         <::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq<
[INFO] [stdout] 2970 | |                             ::bevy_ui::InterpolationColorSpace,
[INFO] [stdout] 2971 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 2972 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2971 -                         >>::eq(&_self, &other)
[INFO] [stdout] 2972 -                         .into();
[INFO] [stdout] 2971 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2969 ~                         <bool as Into<_>>::into(<::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq<
[INFO] [stdout] 2970 |                             ::bevy_ui::InterpolationColorSpace,
[INFO] [stdout] 2971 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3015:44
[INFO] [stdout]      |
[INFO] [stdout] 3015 |                           let output: bool = <::bevy_ui::RadialGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3016 | |                             ::bevy_ui::RadialGradient,
[INFO] [stdout] 3017 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3018 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3017 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3018 -                             .into();
[INFO] [stdout] 3017 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3015 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::RadialGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3016 |                             ::bevy_ui::RadialGradient,
[INFO] [stdout] 3017 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3081:40
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                       let output: bool = <::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3082 | |                         ::bevy_ui::RadialGradientShape,
[INFO] [stdout] 3083 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3084 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3083 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3084 -                     .into();
[INFO] [stdout] 3083 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq<
[INFO] [stdout] 3082 |                         ::bevy_ui::RadialGradientShape,
[INFO] [stdout] 3083 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3164:44
[INFO] [stdout]      |
[INFO] [stdout] 3164 |                           let output: bool = <::bevy_ui::ConicGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3165 | |                             ::bevy_ui::ConicGradient,
[INFO] [stdout] 3166 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3167 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3166 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3167 -                             .into();
[INFO] [stdout] 3166 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3164 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ConicGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3165 |                             ::bevy_ui::ConicGradient,
[INFO] [stdout] 3166 ~                         >>::eq(&_self, &other));
[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_ui::Gradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_ui::Gradient,
[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_ui::Gradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_ui::Gradient,
[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:3297:40
[INFO] [stdout]      |
[INFO] [stdout] 3297 |                     let output: bool = ::bevy_ui::Gradient::is_empty(&_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] 3297 -                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into();
[INFO] [stdout] 3297 +                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                     let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into();
[INFO] [stdout] 3297 +                     let output: bool = <bool as Into<_>>::into(::bevy_ui::Gradient::is_empty(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3336:40
[INFO] [stdout]      |
[INFO] [stdout] 3336 |                       let output: bool = <::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3337 | |                         ::bevy_ui::BackgroundGradient,
[INFO] [stdout] 3338 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3339 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3338 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3339 -                     .into();
[INFO] [stdout] 3338 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3336 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3337 |                         ::bevy_ui::BackgroundGradient,
[INFO] [stdout] 3338 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3382:44
[INFO] [stdout]      |
[INFO] [stdout] 3382 |                           let output: bool = <::bevy_ui::BorderGradient as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3383 | |                             ::bevy_ui::BorderGradient,
[INFO] [stdout] 3384 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3384 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3385 -                             .into();
[INFO] [stdout] 3384 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3382 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderGradient as ::std::cmp::PartialEq<
[INFO] [stdout] 3383 |                             ::bevy_ui::BorderGradient,
[INFO] [stdout] 3384 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3445:44
[INFO] [stdout]      |
[INFO] [stdout] 3445 |                           let output: bool = <::bevy_ui::Val2 as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3446 | |                             ::bevy_ui::Val2,
[INFO] [stdout] 3447 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3448 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3447 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3448 -                             .into();
[INFO] [stdout] 3447 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3445 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::Val2 as ::std::cmp::PartialEq<
[INFO] [stdout] 3446 |                             ::bevy_ui::Val2,
[INFO] [stdout] 3447 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3570:44
[INFO] [stdout]      |
[INFO] [stdout] 3570 |                           let output: bool = <::bevy_ui::UiTransform as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3571 | |                             ::bevy_ui::UiTransform,
[INFO] [stdout] 3572 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3573 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3572 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3573 -                             .into();
[INFO] [stdout] 3572 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3570 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiTransform as ::std::cmp::PartialEq<
[INFO] [stdout] 3571 |                             ::bevy_ui::UiTransform,
[INFO] [stdout] 3572 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3683:25
[INFO] [stdout]      |
[INFO] [stdout] 3683 | /                         <::bevy_ui::DeprecatedInteraction as ::std::cmp::PartialEq<
[INFO] [stdout] 3684 | |                             ::bevy_ui::DeprecatedInteraction,
[INFO] [stdout] 3685 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3686 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3685 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3686 -                         .into();
[INFO] [stdout] 3685 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3683 ~                         <bool as Into<_>>::into(<::bevy_ui::DeprecatedInteraction as ::std::cmp::PartialEq<
[INFO] [stdout] 3684 |                             ::bevy_ui::DeprecatedInteraction,
[INFO] [stdout] 3685 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3729:25
[INFO] [stdout]      |
[INFO] [stdout] 3729 |                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_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] 3729 -                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into();
[INFO] [stdout] 3729 +                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 -                         ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into();
[INFO] [stdout] 3729 +                         <bool as Into<_>>::into(::bevy_ui::RelativeCursorPosition::cursor_over(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3745:25
[INFO] [stdout]      |
[INFO] [stdout] 3745 | /                         <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 3746 | |                             ::bevy_ui::RelativeCursorPosition,
[INFO] [stdout] 3747 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3748 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3747 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3748 -                         .into();
[INFO] [stdout] 3747 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3745 ~                         <bool as Into<_>>::into(<::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq<
[INFO] [stdout] 3746 |                             ::bevy_ui::RelativeCursorPosition,
[INFO] [stdout] 3747 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3843:44
[INFO] [stdout]      |
[INFO] [stdout] 3843 |                           let output: bool = <::bevy_ui::UiRect as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3844 | |                             ::bevy_ui::UiRect,
[INFO] [stdout] 3845 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3846 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3845 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3846 -                             .into();
[INFO] [stdout] 3845 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3843 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::UiRect as ::std::cmp::PartialEq<
[INFO] [stdout] 3844 |                             ::bevy_ui::UiRect,
[INFO] [stdout] 3845 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4142:44
[INFO] [stdout]      |
[INFO] [stdout] 4142 |                           let output: bool = <::bevy_ui::CornerRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4143 | |                             ::bevy_ui::CornerRadius,
[INFO] [stdout] 4144 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4145 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4144 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4145 -                             .into();
[INFO] [stdout] 4144 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4142 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::CornerRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4143 |                             ::bevy_ui::CornerRadius,
[INFO] [stdout] 4144 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4264:44
[INFO] [stdout]      |
[INFO] [stdout] 4264 |                           let output: bool = <::bevy_ui::LayoutConfig as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4265 | |                             ::bevy_ui::LayoutConfig,
[INFO] [stdout] 4266 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4267 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4266 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4267 -                             .into();
[INFO] [stdout] 4266 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4264 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::LayoutConfig as ::std::cmp::PartialEq<
[INFO] [stdout] 4265 |                             ::bevy_ui::LayoutConfig,
[INFO] [stdout] 4266 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4308:40
[INFO] [stdout]      |
[INFO] [stdout] 4308 |                       let output: bool = <::bevy_ui::Outline as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4309 | |                         ::bevy_ui::Outline,
[INFO] [stdout] 4310 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4311 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4310 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4311 -                     .into();
[INFO] [stdout] 4310 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4308 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::Outline as ::std::cmp::PartialEq<
[INFO] [stdout] 4309 |                         ::bevy_ui::Outline,
[INFO] [stdout] 4310 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4370:44
[INFO] [stdout]      |
[INFO] [stdout] 4370 |                           let output: bool = <::bevy_ui::OverflowAxis as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4371 | |                             ::bevy_ui::OverflowAxis,
[INFO] [stdout] 4372 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4373 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4372 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4373 -                             .into();
[INFO] [stdout] 4372 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4370 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OverflowAxis as ::std::cmp::PartialEq<
[INFO] [stdout] 4371 |                             ::bevy_ui::OverflowAxis,
[INFO] [stdout] 4372 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4387:44
[INFO] [stdout]      |
[INFO] [stdout] 4387 |                           let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4388 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4387 -                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout] 4388 -                             .into();
[INFO] [stdout] 4387 +                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4387 -                         let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self)
[INFO] [stdout] 4388 -                             .into();
[INFO] [stdout] 4387 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::OverflowAxis::is_visible(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4460:44
[INFO] [stdout]      |
[INFO] [stdout] 4460 |                           let output: bool = <::bevy_ui::PositionType as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4461 | |                             ::bevy_ui::PositionType,
[INFO] [stdout] 4462 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4463 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4462 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4463 -                             .into();
[INFO] [stdout] 4462 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4460 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::PositionType as ::std::cmp::PartialEq<
[INFO] [stdout] 4461 |                             ::bevy_ui::PositionType,
[INFO] [stdout] 4462 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4506:44
[INFO] [stdout]      |
[INFO] [stdout] 4506 |                           let output: bool = <::bevy_ui::AlignSelf as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4507 | |                             ::bevy_ui::AlignSelf,
[INFO] [stdout] 4508 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4509 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4508 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4509 -                             .into();
[INFO] [stdout] 4508 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4506 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignSelf as ::std::cmp::PartialEq<
[INFO] [stdout] 4507 |                             ::bevy_ui::AlignSelf,
[INFO] [stdout] 4508 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4523:44
[INFO] [stdout]      |
[INFO] [stdout] 4523 |                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_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] 4523 -                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self).into();
[INFO] [stdout] 4523 +                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4523 -                         let output: bool = ::bevy_ui::AlignSelf::is_safe(&_self).into();
[INFO] [stdout] 4523 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignSelf::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4578:40
[INFO] [stdout]      |
[INFO] [stdout] 4578 |                       let output: bool = <::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4579 | |                         ::bevy_ui::RepeatedGridTrack,
[INFO] [stdout] 4580 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4581 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4580 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4581 -                     .into();
[INFO] [stdout] 4580 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4578 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq<
[INFO] [stdout] 4579 |                         ::bevy_ui::RepeatedGridTrack,
[INFO] [stdout] 4580 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4624:44
[INFO] [stdout]      |
[INFO] [stdout] 4624 |                           let output: bool = <::bevy_ui::AlignContent as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4625 | |                             ::bevy_ui::AlignContent,
[INFO] [stdout] 4626 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4627 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4626 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4627 -                             .into();
[INFO] [stdout] 4626 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4624 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignContent as ::std::cmp::PartialEq<
[INFO] [stdout] 4625 |                             ::bevy_ui::AlignContent,
[INFO] [stdout] 4626 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4641:44
[INFO] [stdout]      |
[INFO] [stdout] 4641 |                           let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4642 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4641 -                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout] 4642 -                             .into();
[INFO] [stdout] 4641 +                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4641 -                         let output: bool = ::bevy_ui::AlignContent::is_safe(&_self)
[INFO] [stdout] 4642 -                             .into();
[INFO] [stdout] 4641 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignContent::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4701:40
[INFO] [stdout]      |
[INFO] [stdout] 4701 |                       let output: bool = <::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4702 | |                         ::bevy_ui::ResolvedBorderRadius,
[INFO] [stdout] 4703 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4704 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4703 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4704 -                     .into();
[INFO] [stdout] 4703 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4701 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4702 |                         ::bevy_ui::ResolvedBorderRadius,
[INFO] [stdout] 4703 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4747:44
[INFO] [stdout]      |
[INFO] [stdout] 4747 |                           let output: bool = <::bevy_ui::BorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4748 | |                             ::bevy_ui::BorderRadius,
[INFO] [stdout] 4749 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4750 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4749 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4750 -                             .into();
[INFO] [stdout] 4749 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4747 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderRadius as ::std::cmp::PartialEq<
[INFO] [stdout] 4748 |                             ::bevy_ui::BorderRadius,
[INFO] [stdout] 4749 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4869:44
[INFO] [stdout]      |
[INFO] [stdout] 4869 |                           let output: bool = <::bevy_ui::AlignItems as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4870 | |                             ::bevy_ui::AlignItems,
[INFO] [stdout] 4871 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4872 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4871 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4872 -                             .into();
[INFO] [stdout] 4871 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4869 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::AlignItems as ::std::cmp::PartialEq<
[INFO] [stdout] 4870 |                             ::bevy_ui::AlignItems,
[INFO] [stdout] 4871 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4886:44
[INFO] [stdout]      |
[INFO] [stdout] 4886 |                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_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] 4886 -                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self).into();
[INFO] [stdout] 4886 +                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4886 -                         let output: bool = ::bevy_ui::AlignItems::is_safe(&_self).into();
[INFO] [stdout] 4886 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::AlignItems::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4944:44
[INFO] [stdout]      |
[INFO] [stdout] 4944 |                           let output: bool = <::bevy_ui::FlexDirection as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4945 | |                             ::bevy_ui::FlexDirection,
[INFO] [stdout] 4946 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4947 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4946 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4947 -                             .into();
[INFO] [stdout] 4946 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4944 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::FlexDirection as ::std::cmp::PartialEq<
[INFO] [stdout] 4945 |                             ::bevy_ui::FlexDirection,
[INFO] [stdout] 4946 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4988:40
[INFO] [stdout]      |
[INFO] [stdout] 4988 |                       let output: bool = <::bevy_ui::FlexWrap as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 4989 | |                         ::bevy_ui::FlexWrap,
[INFO] [stdout] 4990 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 4991 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4990 -                     >>::eq(&_self, &other)
[INFO] [stdout] 4991 -                     .into();
[INFO] [stdout] 4990 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4988 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::FlexWrap as ::std::cmp::PartialEq<
[INFO] [stdout] 4989 |                         ::bevy_ui::FlexWrap,
[INFO] [stdout] 4990 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5031:44
[INFO] [stdout]      |
[INFO] [stdout] 5031 |                           let output: bool = <::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5032 | |                             ::bevy_ui::GridAutoFlow,
[INFO] [stdout] 5033 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5034 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5033 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5034 -                             .into();
[INFO] [stdout] 5033 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5031 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq<
[INFO] [stdout] 5032 |                             ::bevy_ui::GridAutoFlow,
[INFO] [stdout] 5033 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5127:44
[INFO] [stdout]      |
[INFO] [stdout] 5127 |                           let output: bool = <::bevy_ui::GridPlacement as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5128 | |                             ::bevy_ui::GridPlacement,
[INFO] [stdout] 5129 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5130 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5129 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5130 -                             .into();
[INFO] [stdout] 5129 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5127 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridPlacement as ::std::cmp::PartialEq<
[INFO] [stdout] 5128 |                             ::bevy_ui::GridPlacement,
[INFO] [stdout] 5129 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<i16>`
[INFO] [stdout]     --> src/lib.rs:5144:66
[INFO] [stdout]      |
[INFO] [stdout] 5144 |                           let output: ::std::option::Option<i16> = ::bevy_ui::GridPlacement::get_end(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5145 | |                                 _self.into_inner(),
[INFO] [stdout] 5146 | |                             )
[INFO] [stdout] 5147 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5146 -                             )
[INFO] [stdout] 5147 -                             .into();
[INFO] [stdout] 5146 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5144 ~                         let output: ::std::option::Option<i16> = <std::option::Option<i16> as Into<_>>::into(::bevy_ui::GridPlacement::get_end(
[INFO] [stdout] 5145 |                                 _self.into_inner(),
[INFO] [stdout] 5146 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]     --> src/lib.rs:5161:66
[INFO] [stdout]      |
[INFO] [stdout] 5161 |                           let output: ::std::option::Option<u16> = ::bevy_ui::GridPlacement::get_span(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5162 | |                                 _self.into_inner(),
[INFO] [stdout] 5163 | |                             )
[INFO] [stdout] 5164 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5163 -                             )
[INFO] [stdout] 5164 -                             .into();
[INFO] [stdout] 5163 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5161 ~                         let output: ::std::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::bevy_ui::GridPlacement::get_span(
[INFO] [stdout] 5162 |                                 _self.into_inner(),
[INFO] [stdout] 5163 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<i16>`
[INFO] [stdout]     --> src/lib.rs:5178:66
[INFO] [stdout]      |
[INFO] [stdout] 5178 |                           let output: ::std::option::Option<i16> = ::bevy_ui::GridPlacement::get_start(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 5179 | |                                 _self.into_inner(),
[INFO] [stdout] 5180 | |                             )
[INFO] [stdout] 5181 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5180 -                             )
[INFO] [stdout] 5181 -                             .into();
[INFO] [stdout] 5180 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5178 ~                         let output: ::std::option::Option<i16> = <std::option::Option<i16> as Into<_>>::into(::bevy_ui::GridPlacement::get_start(
[INFO] [stdout] 5179 |                                 _self.into_inner(),
[INFO] [stdout] 5180 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5348:44
[INFO] [stdout]      |
[INFO] [stdout] 5348 |                           let output: bool = <::bevy_ui::GridTrack as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5349 | |                             ::bevy_ui::GridTrack,
[INFO] [stdout] 5350 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5351 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5350 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5351 -                             .into();
[INFO] [stdout] 5350 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5348 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridTrack as ::std::cmp::PartialEq<
[INFO] [stdout] 5349 |                             ::bevy_ui::GridTrack,
[INFO] [stdout] 5350 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5390:40
[INFO] [stdout]      |
[INFO] [stdout] 5390 |                       let output: bool = <::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 5391 | |                         ::bevy_ui::GridTrackRepetition,
[INFO] [stdout] 5392 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 5393 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5392 -                     >>::eq(&_self, &other)
[INFO] [stdout] 5393 -                     .into();
[INFO] [stdout] 5392 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5390 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq<
[INFO] [stdout] 5391 |                         ::bevy_ui::GridTrackRepetition,
[INFO] [stdout] 5392 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5436:44
[INFO] [stdout]      |
[INFO] [stdout] 5436 |                           let output: bool = <::bevy_ui::InlineDirection as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5437 | |                             ::bevy_ui::InlineDirection,
[INFO] [stdout] 5438 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5439 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5438 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5439 -                             .into();
[INFO] [stdout] 5438 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5436 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::InlineDirection as ::std::cmp::PartialEq<
[INFO] [stdout] 5437 |                             ::bevy_ui::InlineDirection,
[INFO] [stdout] 5438 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5482:44
[INFO] [stdout]      |
[INFO] [stdout] 5482 |                           let output: bool = <::bevy_ui::JustifyContent as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5483 | |                             ::bevy_ui::JustifyContent,
[INFO] [stdout] 5484 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5485 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5484 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5485 -                             .into();
[INFO] [stdout] 5484 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5482 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifyContent as ::std::cmp::PartialEq<
[INFO] [stdout] 5483 |                             ::bevy_ui::JustifyContent,
[INFO] [stdout] 5484 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5499:44
[INFO] [stdout]      |
[INFO] [stdout] 5499 |                           let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5500 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5499 -                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout] 5500 -                             .into();
[INFO] [stdout] 5499 +                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5499 -                         let output: bool = ::bevy_ui::JustifyContent::is_safe(&_self)
[INFO] [stdout] 5500 -                             .into();
[INFO] [stdout] 5499 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifyContent::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5560:44
[INFO] [stdout]      |
[INFO] [stdout] 5560 |                           let output: bool = <::bevy_ui::JustifyItems as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5561 | |                             ::bevy_ui::JustifyItems,
[INFO] [stdout] 5562 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5563 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5562 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5563 -                             .into();
[INFO] [stdout] 5562 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5560 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifyItems as ::std::cmp::PartialEq<
[INFO] [stdout] 5561 |                             ::bevy_ui::JustifyItems,
[INFO] [stdout] 5562 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5577:44
[INFO] [stdout]      |
[INFO] [stdout] 5577 |                           let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5578 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5577 -                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout] 5578 -                             .into();
[INFO] [stdout] 5577 +                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5577 -                         let output: bool = ::bevy_ui::JustifyItems::is_safe(&_self)
[INFO] [stdout] 5578 -                             .into();
[INFO] [stdout] 5577 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifyItems::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5638:44
[INFO] [stdout]      |
[INFO] [stdout] 5638 |                           let output: bool = <::bevy_ui::JustifySelf as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5639 | |                             ::bevy_ui::JustifySelf,
[INFO] [stdout] 5640 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5641 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5640 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5641 -                             .into();
[INFO] [stdout] 5640 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5638 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::JustifySelf as ::std::cmp::PartialEq<
[INFO] [stdout] 5639 |                             ::bevy_ui::JustifySelf,
[INFO] [stdout] 5640 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5655:44
[INFO] [stdout]      |
[INFO] [stdout] 5655 |                           let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5656 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5655 -                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout] 5656 -                             .into();
[INFO] [stdout] 5655 +                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5655 -                         let output: bool = ::bevy_ui::JustifySelf::is_safe(&_self)
[INFO] [stdout] 5656 -                             .into();
[INFO] [stdout] 5655 +                         let output: bool = <bool as Into<_>>::into(::bevy_ui::JustifySelf::is_safe(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5715:25
[INFO] [stdout]      |
[INFO] [stdout] 5715 | /                         <::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5716 | |                             ::bevy_ui::MaxTrackSizingFunction,
[INFO] [stdout] 5717 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5718 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5717 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5718 -                         .into();
[INFO] [stdout] 5717 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5715 ~                         <bool as Into<_>>::into(<::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5716 |                             ::bevy_ui::MaxTrackSizingFunction,
[INFO] [stdout] 5717 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5762:25
[INFO] [stdout]      |
[INFO] [stdout] 5762 | /                         <::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5763 | |                             ::bevy_ui::MinTrackSizingFunction,
[INFO] [stdout] 5764 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5765 | |                         .into();
[INFO] [stdout]      | |_______________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5764 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5765 -                         .into();
[INFO] [stdout] 5764 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5762 ~                         <bool as Into<_>>::into(<::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq<
[INFO] [stdout] 5763 |                             ::bevy_ui::MinTrackSizingFunction,
[INFO] [stdout] 5764 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5841:44
[INFO] [stdout]      |
[INFO] [stdout] 5841 |                           let output: bool = <::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5842 | |                             ::bevy_ui::OverflowClipMargin,
[INFO] [stdout] 5843 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5844 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5843 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5844 -                             .into();
[INFO] [stdout] 5843 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5841 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq<
[INFO] [stdout] 5842 |                             ::bevy_ui::OverflowClipMargin,
[INFO] [stdout] 5843 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5920:44
[INFO] [stdout]      |
[INFO] [stdout] 5920 |                           let output: bool = <::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 5921 | |                             ::bevy_ui::GlobalZIndex,
[INFO] [stdout] 5922 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 5923 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5922 -                         >>::eq(&_self, &other)
[INFO] [stdout] 5923 -                             .into();
[INFO] [stdout] 5922 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5920 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 5921 |                             ::bevy_ui::GlobalZIndex,
[INFO] [stdout] 5922 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:5964:40
[INFO] [stdout]      |
[INFO] [stdout] 5964 |                       let output: bool = <::bevy_ui::ZIndex as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 5965 | |                         ::bevy_ui::ZIndex,
[INFO] [stdout] 5966 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 5967 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5966 -                     >>::eq(&_self, &other)
[INFO] [stdout] 5967 -                     .into();
[INFO] [stdout] 5966 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5964 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::ZIndex as ::std::cmp::PartialEq<
[INFO] [stdout] 5965 |                         ::bevy_ui::ZIndex,
[INFO] [stdout] 5966 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6007:44
[INFO] [stdout]      |
[INFO] [stdout] 6007 |                           let output: bool = <::bevy_ui::BackgroundColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6008 | |                             ::bevy_ui::BackgroundColor,
[INFO] [stdout] 6009 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6010 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6009 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6010 -                             .into();
[INFO] [stdout] 6009 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6007 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BackgroundColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6008 |                             ::bevy_ui::BackgroundColor,
[INFO] [stdout] 6009 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6053:44
[INFO] [stdout]      |
[INFO] [stdout] 6053 |                           let output: bool = <::bevy_ui::BorderColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6054 | |                             ::bevy_ui::BorderColor,
[INFO] [stdout] 6055 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6056 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6055 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6056 -                             .into();
[INFO] [stdout] 6055 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6053 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BorderColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6054 |                             ::bevy_ui::BorderColor,
[INFO] [stdout] 6055 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6070:44
[INFO] [stdout]      |
[INFO] [stdout] 6070 |                           let output: bool = ::bevy_ui::BorderColor::is_fully_transparent(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6071 | |                                 &_self,
[INFO] [stdout] 6072 | |                             )
[INFO] [stdout] 6073 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6072 -                             )
[INFO] [stdout] 6073 -                             .into();
[INFO] [stdout] 6072 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6070 ~                         let output: bool = <bool as Into<_>>::into(::bevy_ui::BorderColor::is_fully_transparent(
[INFO] [stdout] 6071 |                                 &_self,
[INFO] [stdout] 6072 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6113:40
[INFO] [stdout]      |
[INFO] [stdout] 6113 |                       let output: bool = <::bevy_ui::CalculatedClipRect as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 6114 | |                         ::bevy_ui::CalculatedClipRect,
[INFO] [stdout] 6115 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 6116 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6115 -                     >>::eq(&_self, &other)
[INFO] [stdout] 6116 -                     .into();
[INFO] [stdout] 6115 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6113 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_ui::CalculatedClipRect as ::std::cmp::PartialEq<
[INFO] [stdout] 6114 |                         ::bevy_ui::CalculatedClipRect,
[INFO] [stdout] 6115 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6159:44
[INFO] [stdout]      |
[INFO] [stdout] 6159 |                           let output: bool = <::bevy_ui::OuterColor as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6160 | |                             ::bevy_ui::OuterColor,
[INFO] [stdout] 6161 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6162 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6161 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6162 -                             .into();
[INFO] [stdout] 6161 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6159 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::OuterColor as ::std::cmp::PartialEq<
[INFO] [stdout] 6160 |                             ::bevy_ui::OuterColor,
[INFO] [stdout] 6161 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6203:44
[INFO] [stdout]      |
[INFO] [stdout] 6203 |                           let output: bool = <::bevy_ui::BoxShadow as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6204 | |                             ::bevy_ui::BoxShadow,
[INFO] [stdout] 6205 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6206 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6205 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6206 -                             .into();
[INFO] [stdout] 6205 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6203 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::BoxShadow as ::std::cmp::PartialEq<
[INFO] [stdout] 6204 |                             ::bevy_ui::BoxShadow,
[INFO] [stdout] 6205 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6273:44
[INFO] [stdout]      |
[INFO] [stdout] 6273 |                           let output: bool = <::bevy_ui::ShadowStyle as ::std::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6274 | |                             ::bevy_ui::ShadowStyle,
[INFO] [stdout] 6275 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6276 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6275 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6276 -                             .into();
[INFO] [stdout] 6275 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6273 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_ui::ShadowStyle as ::std::cmp::PartialEq<
[INFO] [stdout] 6274 |                             ::bevy_ui::ShadowStyle,
[INFO] [stdout] 6275 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `bevy_ui_bms_bindings` (lib test) due to 92 previous errors
[INFO] [stderr] warning: unused dependency `bevy_mod_scripting_core`
[INFO] [stderr]   --> Cargo.toml:70:15
[INFO] [stderr]    |
[INFO] [stderr] 70 | [dependencies.bevy_mod_scripting_core]
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `bevy_mod_scripting_core`
[INFO] [stderr] warning: `bevy_ui_bms_bindings` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8", kill_on_drop: false }`
[INFO] [stdout] fbc8d1e105ad10a12d2f463cd75bac75d454977b39149d90968d94ac306223e8
