[INFO] cloning repository https://github.com/dhilipsiva/fanva
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/dhilipsiva/fanva" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fdhilipsiva%2Ffanva", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fdhilipsiva%2Ffanva'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] e1520f70f8a2f45eb5a252cf14f22541e459203c
[INFO] checking dhilipsiva/fanva against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fdhilipsiva%2Ffanva" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/dhilipsiva/fanva
[INFO] finished tweaking git repo https://github.com/dhilipsiva/fanva
[INFO] tweaked toml for git repo https://github.com/dhilipsiva/fanva written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/dhilipsiva/fanva on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/dhilipsiva/fanva already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-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] fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a
[INFO] running `Command { std: "docker" "start" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a", 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" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a", 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" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.106
[INFO] [stderr]    Compiling unicode-ident v1.0.24
[INFO] [stderr]    Compiling quote v1.0.46
[INFO] [stderr]     Checking cfg-if v1.0.4
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]     Checking once_cell v1.21.4
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]     Checking memchr v2.8.3
[INFO] [stderr]     Checking pin-project-lite v0.2.17
[INFO] [stderr]    Compiling rustversion v1.0.23
[INFO] [stderr]    Compiling zmij v1.0.21
[INFO] [stderr]     Checking futures-core v0.3.32
[INFO] [stderr]     Checking futures-sink v0.3.32
[INFO] [stderr]     Checking slab v0.4.12
[INFO] [stderr]     Checking futures-channel v0.3.32
[INFO] [stderr]     Checking futures-task v0.3.32
[INFO] [stderr]     Checking futures-io v0.3.32
[INFO] [stderr]    Compiling serde_json v1.0.150
[INFO] [stderr]    Compiling wasm-bindgen-shared v0.2.126
[INFO] [stderr]    Compiling libc v0.2.186
[INFO] [stderr]    Compiling siphasher v1.0.3
[INFO] [stderr]    Compiling zerocopy v0.8.54
[INFO] [stderr]    Compiling phf_shared v0.13.1
[INFO] [stderr]    Compiling bumpalo v3.20.3
[INFO] [stderr]    Compiling fastrand v2.4.1
[INFO] [stderr]    Compiling phf_generator v0.13.1
[INFO] [stderr]    Compiling syn v2.0.118
[INFO] [stderr]    Compiling aho-corasick v1.1.4
[INFO] [stderr]    Compiling wasm-bindgen v0.2.126
[INFO] [stderr]    Compiling regex-syntax v0.8.11
[INFO] [stderr]    Compiling itoa v1.0.18
[INFO] [stderr]    Compiling phf_codegen v0.13.1
[INFO] [stderr]    Compiling thiserror v2.0.18
[INFO] [stderr]     Checking tracing-core v0.1.36
[INFO] [stderr]     Checking phf v0.13.1
[INFO] [stderr]    Compiling parking_lot_core v0.9.12
[INFO] [stderr]     Checking smallvec v1.15.2
[INFO] [stderr]     Checking lock_api v0.4.14
[INFO] [stderr]    Compiling slotmap v1.1.1
[INFO] [stderr]    Compiling unicode-xid v0.2.6
[INFO] [stderr]    Compiling anyhow v1.0.103
[INFO] [stderr]     Checking dioxus-core-types v0.7.9
[INFO] [stderr]     Checking konst_macro_rules v0.2.19
[INFO] [stderr]     Checking konst v0.2.20
[INFO] [stderr]    Compiling const_format_proc_macros v0.2.34
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]     Checking libloading v0.8.9
[INFO] [stderr]    Compiling ahash v0.8.12
[INFO] [stderr]     Checking rustc-hash v2.1.3
[INFO] [stderr]     Checking longest-increasing-subsequence v0.1.0
[INFO] [stderr]    Compiling regex-automata v0.4.15
[INFO] [stderr]    Compiling lazy-js-bundle v0.7.9
[INFO] [stderr]     Checking typenum v1.20.1
[INFO] [stderr]     Checking const_format v0.2.36
[INFO] [stderr]    Compiling unicode-segmentation v1.13.3
[INFO] [stderr]    Compiling getrandom v0.3.4
[INFO] [stderr]    Compiling convert_case v0.8.0
[INFO] [stderr]    Compiling proc-macro2-diagnostics v0.10.1
[INFO] [stderr]    Compiling autocfg v1.5.1
[INFO] [stderr]     Checking bytes v1.12.1
[INFO] [stderr]     Checking rand_core v0.9.5
[INFO] [stderr]     Checking bitflags v2.13.0
[INFO] [stderr]     Checking keyboard-types v0.7.0
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling dioxus-document v0.7.9
[INFO] [stderr]    Compiling dioxus-interpreter-js v0.7.9
[INFO] [stderr]     Checking http v1.4.2
[INFO] [stderr]     Checking log v0.4.33
[INFO] [stderr]     Checking lazy_static v1.5.0
[INFO] [stderr]     Checking rustc-hash v1.1.0
[INFO] [stderr]     Checking generic-array v0.14.7
[INFO] [stderr]    Compiling winnow v0.7.15
[INFO] [stderr]    Compiling wasm-bindgen-macro-support v0.2.126
[INFO] [stderr]    Compiling darling_core v0.21.3
[INFO] [stderr]     Checking crypto-common v0.1.7
[INFO] [stderr]     Checking block-buffer v0.10.4
[INFO] [stderr]     Checking digest v0.10.7
[INFO] [stderr]    Compiling dioxus-rsx v0.7.9
[INFO] [stderr]     Checking sha1 v0.10.7
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]     Checking hashbrown v0.14.5
[INFO] [stderr]    Compiling logos-codegen v0.16.1
[INFO] [stderr]     Checking lasso v0.7.3
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling futures-macro v0.3.32
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]     Checking futures-util v0.3.32
[INFO] [stderr]    Compiling thiserror-impl v2.0.18
[INFO] [stderr]    Compiling pin-project-internal v1.1.13
[INFO] [stderr]    Compiling logos-derive v0.16.1
[INFO] [stderr]     Checking logos v0.16.1
[INFO] [stderr]    Compiling warnings-macro v0.2.0
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]    Compiling const-serialize-macro v0.7.2
[INFO] [stderr]    Compiling darling_macro v0.21.3
[INFO] [stderr]     Checking generational-box v0.7.9
[INFO] [stderr]    Compiling const-serialize-macro v0.8.0-alpha.0
[INFO] [stderr]    Compiling darling v0.21.3
[INFO] [stderr]    Compiling const-serialize v0.7.2
[INFO] [stderr]     Checking pin-project v1.1.13
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]    Compiling enumset_derive v0.15.0
[INFO] [stderr]     Checking warnings v0.2.1
[INFO] [stderr]    Compiling dioxus-core-macro v0.7.9
[INFO] [stderr]    Compiling dioxus-html-internal-macro v0.7.9
[INFO] [stderr]    Compiling sledgehammer_bindgen_macro v0.6.5
[INFO] [stderr]     Checking rand v0.9.5
[INFO] [stderr]    Compiling async-trait v0.1.89
[INFO] [stderr]    Compiling wasm-bindgen-macro v0.2.126
[INFO] [stderr]     Checking euclid v0.22.14
[INFO] [stderr]     Checking enumset v1.1.13
[INFO] [stderr]     Checking utf-8 v0.7.6
[INFO] [stderr]     Checking data-encoding v2.11.0
[INFO] [stderr]    Compiling macro-string v0.1.4
[INFO] [stderr]     Checking futures-executor v0.3.32
[INFO] [stderr]     Checking sledgehammer_utils v0.3.1
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]    Compiling dioxus-web v0.7.9
[INFO] [stderr]     Checking tungstenite v0.28.0
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]    Compiling dunce v1.0.5
[INFO] [stderr]     Checking futures v0.3.32
[INFO] [stderr]    Compiling dioxus-stores-macro v0.7.9
[INFO] [stderr]     Checking send_wrapper v0.6.0
[INFO] [stderr]    Compiling dioxus-config-macro v0.7.9
[INFO] [stderr]     Checking dioxus-config-macros v0.7.9
[INFO] [stderr]     Checking nibli-types v0.1.0 (/opt/rustwide/workdir/nibli-types)
[INFO] [stderr]     Checking subsecond-types v0.7.9
[INFO] [stderr]     Checking subsecond v0.7.9
[INFO] [stderr]    Compiling smuni-dictionary v0.1.0 (/opt/rustwide/workdir/smuni-dictionary)
[INFO] [stderr]     Checking js-sys v0.3.103
[INFO] [stderr]     Checking dioxus-cli-config v0.7.9
[INFO] [stderr]    Compiling const-serialize v0.8.0-alpha.0
[INFO] [stderr]     Checking sledgehammer_bindgen v0.6.0
[INFO] [stderr]     Checking matchers v0.2.0
[INFO] [stderr]     Checking gerna v0.1.0 (/opt/rustwide/workdir/gerna)
[INFO] [stderr]     Checking nibli-protocol v0.1.0 (/opt/rustwide/workdir/nibli-protocol)
[INFO] [stderr]    Compiling manganis-core v0.7.9
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr] warning: smuni-dictionary@0.1.0: dictionary-en.json not found, using fallback dictionary entries
[INFO] [stderr] warning: smuni-dictionary@0.1.0: dictionary: 178 entries (97 gismu, 0 lujvo, 81 cmavo)
[INFO] [stderr]     Checking nibli-render v0.1.0 (/opt/rustwide/workdir/nibli-render)
[INFO] [stderr]     Checking dioxus-core v0.7.9
[INFO] [stderr]     Checking smuni v0.1.0 (/opt/rustwide/workdir/smuni)
[INFO] [stderr]     Checking fanva-verify v0.1.0 (/opt/rustwide/workdir/fanva-verify)
[INFO] [stderr]    Compiling manganis-macro v0.7.9
[INFO] [stderr]     Checking fanva v0.1.0 (/opt/rustwide/workdir/fanva)
[INFO] [stderr]     Checking dioxus-logger v0.7.9
[INFO] [stderr]     Checking manganis v0.7.9
[INFO] [stderr]     Checking dioxus-signals v0.7.9
[INFO] [stderr]     Checking dioxus-devtools-types v0.7.9
[INFO] [stderr]     Checking dioxus-history v0.7.9
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/grammar_tests.rs:75:39
[INFO] [stdout]    |
[INFO] [stdout] 75 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 75 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 75 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 75 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/grammar_tests.rs:87:39
[INFO] [stdout]    |
[INFO] [stdout] 87 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 87 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 87 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 87 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:101:39
[INFO] [stdout]     |
[INFO] [stdout] 101 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 101 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 101 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 101 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:229:48
[INFO] [stdout]     |
[INFO] [stdout] 229 |             assert_eq!(lb.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 229 -             assert_eq!(lb.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 229 +             assert_eq!(lb.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 -             assert_eq!(lb.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 229 +             assert_eq!(lb.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:231:48
[INFO] [stdout]     |
[INFO] [stdout] 231 |             assert_eq!(rb.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 231 -             assert_eq!(rb.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 231 +             assert_eq!(rb.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 -             assert_eq!(rb.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 231 +             assert_eq!(rb.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:259:47
[INFO] [stdout]     |
[INFO] [stdout] 259 |             assert_eq!(b.selbri, Selbri::Root("pendo".into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -             assert_eq!(b.selbri, Selbri::Root("pendo".into()));
[INFO] [stdout] 259 +             assert_eq!(b.selbri, Selbri::Root("pendo"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -             assert_eq!(b.selbri, Selbri::Root("pendo".into()));
[INFO] [stdout] 259 +             assert_eq!(b.selbri, Selbri::Root(<&str as Into<_>>::into("pendo")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:282:39
[INFO] [stdout]     |
[INFO] [stdout] 282 |     assert_eq!(b.selbri, Selbri::Root("danlu".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -     assert_eq!(b.selbri, Selbri::Root("danlu".into()));
[INFO] [stdout] 282 +     assert_eq!(b.selbri, Selbri::Root("danlu"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -     assert_eq!(b.selbri, Selbri::Root("danlu".into()));
[INFO] [stdout] 282 +     assert_eq!(b.selbri, Selbri::Root(<&str as Into<_>>::into("danlu")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:487:48
[INFO] [stdout]     |
[INFO] [stdout] 487 |             assert_eq!(rb.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -             assert_eq!(rb.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 487 +             assert_eq!(rb.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -             assert_eq!(rb.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 487 +             assert_eq!(rb.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:510:40
[INFO] [stdout]     |
[INFO] [stdout] 510 |     assert_eq!(b0.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 510 -     assert_eq!(b0.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 510 +     assert_eq!(b0.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 510 -     assert_eq!(b0.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 510 +     assert_eq!(b0.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:512:40
[INFO] [stdout]     |
[INFO] [stdout] 512 |     assert_eq!(b1.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 512 -     assert_eq!(b1.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 512 +     assert_eq!(b1.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 512 -     assert_eq!(b1.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 512 +     assert_eq!(b1.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:529:39
[INFO] [stdout]     |
[INFO] [stdout] 529 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 529 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 529 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 529 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:588:39
[INFO] [stdout]     |
[INFO] [stdout] 588 |     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 588 -     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout] 588 +     assert_eq!(s.selbri, Selbri::Root("citka"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 588 -     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout] 588 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("citka")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:589:51
[INFO] [stdout]     |
[INFO] [stdout] 589 |     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout]     |                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 589 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 589 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi")]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 589 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 589 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:594:46
[INFO] [stdout]     |
[INFO] [stdout] 594 |             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 594 -             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout] 594 +             assert_eq!(**inner, Selbri::Root("plise"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 594 -             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout] 594 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("plise")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:610:49
[INFO] [stdout]     |
[INFO] [stdout] 610 |             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 610 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 610 +             assert_eq!(**inner, Sumti::ProSumti("mi"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 610 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 610 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:702:46
[INFO] [stdout]     |
[INFO] [stdout] 702 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 702 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 702 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 702 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 702 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:738:39
[INFO] [stdout]     |
[INFO] [stdout] 738 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 738 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 738 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 738 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 738 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:848:25
[INFO] [stdout]     |
[INFO] [stdout] 848 |         Sumti::ProSumti("mi".into())
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 848 -         Sumti::ProSumti("mi".into())
[INFO] [stdout] 848 +         Sumti::ProSumti("mi")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 848 -         Sumti::ProSumti("mi".into())
[INFO] [stdout] 848 +         Sumti::ProSumti(<&str as Into<_>>::into("mi"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:852:25
[INFO] [stdout]     |
[INFO] [stdout] 852 |         Sumti::ProSumti("do".into())
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 852 -         Sumti::ProSumti("do".into())
[INFO] [stdout] 852 +         Sumti::ProSumti("do")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 852 -         Sumti::ProSumti("do".into())
[INFO] [stdout] 852 +         Sumti::ProSumti(<&str as Into<_>>::into("do"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:863:25
[INFO] [stdout]     |
[INFO] [stdout] 863 |         Sumti::ProSumti("da".into())
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 863 -         Sumti::ProSumti("da".into())
[INFO] [stdout] 863 +         Sumti::ProSumti("da")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 -         Sumti::ProSumti("da".into())
[INFO] [stdout] 863 +         Sumti::ProSumti(<&str as Into<_>>::into("da"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:867:25
[INFO] [stdout]     |
[INFO] [stdout] 867 |         Sumti::ProSumti("de".into())
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 867 -         Sumti::ProSumti("de".into())
[INFO] [stdout] 867 +         Sumti::ProSumti("de")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 -         Sumti::ProSumti("de".into())
[INFO] [stdout] 867 +         Sumti::ProSumti(<&str as Into<_>>::into("de"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:903:25
[INFO] [stdout]     |
[INFO] [stdout] 903 |         Sumti::ProSumti("ma".into())
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 903 -         Sumti::ProSumti("ma".into())
[INFO] [stdout] 903 +         Sumti::ProSumti("ma")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 903 -         Sumti::ProSumti("ma".into())
[INFO] [stdout] 903 +         Sumti::ProSumti(<&str as Into<_>>::into("ma"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:941:46
[INFO] [stdout]     |
[INFO] [stdout] 941 |             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 941 -             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout] 941 +             assert_eq!(**inner, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 -             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout] 941 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:994:42
[INFO] [stdout]     |
[INFO] [stdout] 994 |             assert_eq!(**m, Selbri::Root("sutra".into()));
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 994 -             assert_eq!(**m, Selbri::Root("sutra".into()));
[INFO] [stdout] 994 +             assert_eq!(**m, Selbri::Root("sutra"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 994 -             assert_eq!(**m, Selbri::Root("sutra".into()));
[INFO] [stdout] 994 +             assert_eq!(**m, Selbri::Root(<&str as Into<_>>::into("sutra")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/grammar_tests.rs:995:42
[INFO] [stdout]     |
[INFO] [stdout] 995 |             assert_eq!(**h, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 995 -             assert_eq!(**h, Selbri::Root("gerku".into()));
[INFO] [stdout] 995 +             assert_eq!(**h, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 995 -             assert_eq!(**h, Selbri::Root("gerku".into()));
[INFO] [stdout] 995 +             assert_eq!(**h, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1008:42
[INFO] [stdout]      |
[INFO] [stdout] 1008 |             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1008 -             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout] 1008 +             assert_eq!(**a, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1008 -             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout] 1008 +             assert_eq!(**a, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1011:50
[INFO] [stdout]      |
[INFO] [stdout] 1011 |                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1011 -                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout] 1011 +                     assert_eq!(**b, Selbri::Root("sutra"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1011 -                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout] 1011 +                     assert_eq!(**b, Selbri::Root(<&str as Into<_>>::into("sutra")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1012:50
[INFO] [stdout]      |
[INFO] [stdout] 1012 |                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1012 -                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout] 1012 +                     assert_eq!(**c, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1012 -                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout] 1012 +                     assert_eq!(**c, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1083:54
[INFO] [stdout]      |
[INFO] [stdout] 1083 |                     assert_eq!(**right, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                     assert_eq!(**right, Selbri::Root("gerku".into()));
[INFO] [stdout] 1083 +                     assert_eq!(**right, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 -                     assert_eq!(**right, Selbri::Root("gerku".into()));
[INFO] [stdout] 1083 +                     assert_eq!(**right, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1128:45
[INFO] [stdout]      |
[INFO] [stdout] 1128 |             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1128 -             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout] 1128 +             assert_eq!(**core, Selbri::Root("nelci"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1128 -             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout] 1128 +             assert_eq!(**core, Selbri::Root(<&str as Into<_>>::into("nelci")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1310:46
[INFO] [stdout]      |
[INFO] [stdout] 1310 |             assert_eq!(**right, Selbri::Root("cmalu".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1310 -             assert_eq!(**right, Selbri::Root("cmalu".into()));
[INFO] [stdout] 1310 +             assert_eq!(**right, Selbri::Root("cmalu"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1310 -             assert_eq!(**right, Selbri::Root("cmalu".into()));
[INFO] [stdout] 1310 +             assert_eq!(**right, Selbri::Root(<&str as Into<_>>::into("cmalu")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1383:39
[INFO] [stdout]      |
[INFO] [stdout] 1383 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1383 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1383 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1383 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1383 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1406:56
[INFO] [stdout]      |
[INFO] [stdout] 1406 |             assert_eq!(body_bridi.selbri, Selbri::Root("nelci".into()));
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1406 -             assert_eq!(body_bridi.selbri, Selbri::Root("nelci".into()));
[INFO] [stdout] 1406 +             assert_eq!(body_bridi.selbri, Selbri::Root("nelci"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1406 -             assert_eq!(body_bridi.selbri, Selbri::Root("nelci".into()));
[INFO] [stdout] 1406 +             assert_eq!(body_bridi.selbri, Selbri::Root(<&str as Into<_>>::into("nelci")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1449:46
[INFO] [stdout]      |
[INFO] [stdout] 1449 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1449 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 1449 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1449 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 1449 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1495:39
[INFO] [stdout]      |
[INFO] [stdout] 1495 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1495 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 1495 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1495 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 1495 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1624:39
[INFO] [stdout]      |
[INFO] [stdout] 1624 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1624 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1624 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1624 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1624 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1918:39
[INFO] [stdout]      |
[INFO] [stdout] 1918 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1918 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1918 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1918 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1918 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1941:39
[INFO] [stdout]      |
[INFO] [stdout] 1941 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1941 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1941 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1941 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1941 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1943:49
[INFO] [stdout]      |
[INFO] [stdout] 1943 |     assert_eq!(s.head_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1943 -     assert_eq!(s.head_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout] 1943 +     assert_eq!(s.head_terms[0], Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1943 -     assert_eq!(s.head_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout] 1943 +     assert_eq!(s.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1962:49
[INFO] [stdout]      |
[INFO] [stdout] 1962 |     assert_eq!(s.head_terms[0], Sumti::ProSumti("do".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1962 -     assert_eq!(s.head_terms[0], Sumti::ProSumti("do".into()));
[INFO] [stdout] 1962 +     assert_eq!(s.head_terms[0], Sumti::ProSumti("do"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1962 -     assert_eq!(s.head_terms[0], Sumti::ProSumti("do".into()));
[INFO] [stdout] 1962 +     assert_eq!(s.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1963:49
[INFO] [stdout]      |
[INFO] [stdout] 1963 |     assert_eq!(s.tail_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1963 -     assert_eq!(s.tail_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout] 1963 +     assert_eq!(s.tail_terms[0], Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1963 -     assert_eq!(s.tail_terms[0], Sumti::ProSumti("mi".into()));
[INFO] [stdout] 1963 +     assert_eq!(s.tail_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:1973:39
[INFO] [stdout]      |
[INFO] [stdout] 1973 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1973 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1973 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1973 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 1973 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2009:39
[INFO] [stdout]      |
[INFO] [stdout] 2009 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2009 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2009 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2009 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2009 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2077:43
[INFO] [stdout]      |
[INFO] [stdout] 2077 |     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2077 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2077 +     assert_eq!(bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2077 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2077 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2082:66
[INFO] [stdout]      |
[INFO] [stdout] 2082 |             assert_eq!(body_bridi.tail_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout]      |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2082 -             assert_eq!(body_bridi.tail_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout] 2082 +             assert_eq!(body_bridi.tail_terms[0], Sumti::ProSumti("ke'a"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2082 -             assert_eq!(body_bridi.tail_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout] 2082 +             assert_eq!(body_bridi.tail_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("ke'a")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2109:43
[INFO] [stdout]      |
[INFO] [stdout] 2109 |     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2109 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2109 +     assert_eq!(bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2109 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2109 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2116:66
[INFO] [stdout]      |
[INFO] [stdout] 2116 |             assert_eq!(body_bridi.head_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout]      |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2116 -             assert_eq!(body_bridi.head_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout] 2116 +             assert_eq!(body_bridi.head_terms[0], Sumti::ProSumti("ke'a"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2116 -             assert_eq!(body_bridi.head_terms[0], Sumti::ProSumti("ke'a".into()));
[INFO] [stdout] 2116 +             assert_eq!(body_bridi.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("ke'a")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2148:48
[INFO] [stdout]      |
[INFO] [stdout] 2148 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2148 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 2148 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2148 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 2148 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2151:49
[INFO] [stdout]      |
[INFO] [stdout] 2151 |             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2151 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 2151 +             assert_eq!(**right, Sumti::ProSumti("do"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2151 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 2151 +             assert_eq!(**right, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2155:39
[INFO] [stdout]      |
[INFO] [stdout] 2155 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2155 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2155 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2155 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2155 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2441:48
[INFO] [stdout]      |
[INFO] [stdout] 2441 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2441 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 2441 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2441 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 2441 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2450:62
[INFO] [stdout]      |
[INFO] [stdout] 2450 |                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout]      |                                                              ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2450 -                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout] 2450 +                     assert_eq!(**inner_left, Sumti::ProSumti("do"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2450 -                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout] 2450 +                     assert_eq!(**inner_left, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2451:63
[INFO] [stdout]      |
[INFO] [stdout] 2451 |                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout]      |                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2451 -                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout] 2451 +                     assert_eq!(**inner_right, Sumti::ProSumti("di"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2451 -                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout] 2451 +                     assert_eq!(**inner_right, Sumti::ProSumti(<&str as Into<_>>::into("di")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2477:39
[INFO] [stdout]      |
[INFO] [stdout] 2477 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2477 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2477 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2477 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2477 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2601:39
[INFO] [stdout]      |
[INFO] [stdout] 2601 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2601 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2601 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2601 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 2601 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2661:43
[INFO] [stdout]      |
[INFO] [stdout] 2661 |     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2661 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2661 +     assert_eq!(bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2661 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2661 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2698:83
[INFO] [stdout]      |
[INFO] [stdout] 2698 | ...                   assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout]      |                                                                             ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2698 -                             assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 2698 +                             assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2698 -                             assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 2698 +                             assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("ce'u")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2819:53
[INFO] [stdout]      |
[INFO] [stdout] 2819 |     assert_eq!(bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2819 -     assert_eq!(bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 2819 +     assert_eq!(bridi.head_terms[0], Sumti::ProSumti("ce'u"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2819 -     assert_eq!(bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 2819 +     assert_eq!(bridi.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("ce'u")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2839:43
[INFO] [stdout]      |
[INFO] [stdout] 2839 |     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2839 +     assert_eq!(bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2839 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2839 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2865:43
[INFO] [stdout]      |
[INFO] [stdout] 2865 |     assert_eq!(bridi.selbri, Selbri::Root("xamgu".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2865 -     assert_eq!(bridi.selbri, Selbri::Root("xamgu".into()));
[INFO] [stdout] 2865 +     assert_eq!(bridi.selbri, Selbri::Root("xamgu"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2865 -     assert_eq!(bridi.selbri, Selbri::Root("xamgu".into()));
[INFO] [stdout] 2865 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("xamgu")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:2873:73
[INFO] [stdout]      |
[INFO] [stdout] 2873 | ...                   assert_eq!(inner_bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2873 -                             assert_eq!(inner_bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2873 +                             assert_eq!(inner_bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2873 -                             assert_eq!(inner_bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 2873 +                             assert_eq!(inner_bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3008:53
[INFO] [stdout]      |
[INFO] [stdout] 3008 |                 assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3008 -                 assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3008 +                 assert_eq!(**inner, Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3008 -                 assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3008 +                 assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3033:47
[INFO] [stdout]      |
[INFO] [stdout] 3033 |             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3033 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 3033 +             assert_eq!(**selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3033 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 3033 +             assert_eq!(**selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3034:49
[INFO] [stdout]      |
[INFO] [stdout] 3034 |             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3034 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3034 +             assert_eq!(**inner, Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3034 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3034 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3052:47
[INFO] [stdout]      |
[INFO] [stdout] 3052 |             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3052 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 3052 +             assert_eq!(**selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3052 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 3052 +             assert_eq!(**selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3053:49
[INFO] [stdout]      |
[INFO] [stdout] 3053 |             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3053 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3053 +             assert_eq!(**inner, Sumti::ProSumti("mi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3053 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 3053 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3147:46
[INFO] [stdout]      |
[INFO] [stdout] 3147 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3147 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 3147 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3147 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 3147 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3151:39
[INFO] [stdout]      |
[INFO] [stdout] 3151 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3151 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3151 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3151 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3151 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3291:46
[INFO] [stdout]      |
[INFO] [stdout] 3291 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3291 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 3291 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3291 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 3291 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3318:46
[INFO] [stdout]      |
[INFO] [stdout] 3318 |             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3318 -             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout] 3318 +             assert_eq!(**inner, Selbri::Root("mlatu"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3318 -             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout] 3318 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("mlatu")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3500:43
[INFO] [stdout]      |
[INFO] [stdout] 3500 |     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3500 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3500 +     assert_eq!(bridi.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3500 -     assert_eq!(bridi.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3500 +     assert_eq!(bridi.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:3824:39
[INFO] [stdout]      |
[INFO] [stdout] 3824 |     assert_eq!(b.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3824 -     assert_eq!(b.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3824 +     assert_eq!(b.selbri, Selbri::Root("barda"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3824 -     assert_eq!(b.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 3824 +     assert_eq!(b.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4458:42
[INFO] [stdout]      |
[INFO] [stdout] 4458 |             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4458 -             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout] 4458 +             assert_eq!(**m, Selbri::Root("menli"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4458 -             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout] 4458 +             assert_eq!(**m, Selbri::Root(<&str as Into<_>>::into("menli")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4461:54
[INFO] [stdout]      |
[INFO] [stdout] 4461 |                     assert_eq!(**inner, Selbri::Root("ponse".into()));
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4461 -                     assert_eq!(**inner, Selbri::Root("ponse".into()));
[INFO] [stdout] 4461 +                     assert_eq!(**inner, Selbri::Root("ponse"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4461 -                     assert_eq!(**inner, Selbri::Root("ponse".into()));
[INFO] [stdout] 4461 +                     assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("ponse")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4489:56
[INFO] [stdout]      |
[INFO] [stdout] 4489 |                     assert_eq!(**inner_s, Selbri::Root("krinu".into()));
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4489 -                     assert_eq!(**inner_s, Selbri::Root("krinu".into()));
[INFO] [stdout] 4489 +                     assert_eq!(**inner_s, Selbri::Root("krinu"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4489 -                     assert_eq!(**inner_s, Selbri::Root("krinu".into()));
[INFO] [stdout] 4489 +                     assert_eq!(**inner_s, Selbri::Root(<&str as Into<_>>::into("krinu")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4523:64
[INFO] [stdout]      |
[INFO] [stdout] 4523 | ...                   assert_eq!(**inner_s, Selbri::Root("ponse".into()));
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                             assert_eq!(**inner_s, Selbri::Root("ponse".into()));
[INFO] [stdout] 4523 +                             assert_eq!(**inner_s, Selbri::Root("ponse"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4523 -                             assert_eq!(**inner_s, Selbri::Root("ponse".into()));
[INFO] [stdout] 4523 +                             assert_eq!(**inner_s, Selbri::Root(<&str as Into<_>>::into("ponse")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4527:50
[INFO] [stdout]      |
[INFO] [stdout] 4527 |                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4527 -                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout] 4527 +                     assert_eq!(**h, Selbri::Root("datni"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4527 -                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout] 4527 +                     assert_eq!(**h, Selbri::Root(<&str as Into<_>>::into("datni")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4566:50
[INFO] [stdout]      |
[INFO] [stdout] 4566 |                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4566 -                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout] 4566 +                     assert_eq!(**h, Selbri::Root("datni"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4566 -                     assert_eq!(**h, Selbri::Root("datni".into()));
[INFO] [stdout] 4566 +                     assert_eq!(**h, Selbri::Root(<&str as Into<_>>::into("datni")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4576:46
[INFO] [stdout]      |
[INFO] [stdout] 4576 |             assert_eq!(**inner, Selbri::Root("fanta".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4576 -             assert_eq!(**inner, Selbri::Root("fanta".into()));
[INFO] [stdout] 4576 +             assert_eq!(**inner, Selbri::Root("fanta"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4576 -             assert_eq!(**inner, Selbri::Root("fanta".into()));
[INFO] [stdout] 4576 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("fanta")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4611:46
[INFO] [stdout]      |
[INFO] [stdout] 4611 |             assert_eq!(**inner, Selbri::Root("nibli".into()));
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4611 -             assert_eq!(**inner, Selbri::Root("nibli".into()));
[INFO] [stdout] 4611 +             assert_eq!(**inner, Selbri::Root("nibli"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4611 -             assert_eq!(**inner, Selbri::Root("nibli".into()));
[INFO] [stdout] 4611 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("nibli")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4639:39
[INFO] [stdout]      |
[INFO] [stdout] 4639 |     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4639 -     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 4639 +     assert_eq!(b.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4639 -     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 4639 +     assert_eq!(b.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4658:39
[INFO] [stdout]      |
[INFO] [stdout] 4658 |     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4658 -     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 4658 +     assert_eq!(b.selbri, Selbri::Root("klama"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4658 -     assert_eq!(b.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 4658 +     assert_eq!(b.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4684:56
[INFO] [stdout]      |
[INFO] [stdout] 4684 |                     assert_eq!(**inner_s, Selbri::Root("gerku".into()));
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4684 -                     assert_eq!(**inner_s, Selbri::Root("gerku".into()));
[INFO] [stdout] 4684 +                     assert_eq!(**inner_s, Selbri::Root("gerku"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4684 -                     assert_eq!(**inner_s, Selbri::Root("gerku".into()));
[INFO] [stdout] 4684 +                     assert_eq!(**inner_s, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4714:63
[INFO] [stdout]      |
[INFO] [stdout] 4714 |                         assert_eq!(**conv_inner, Selbri::Root("curmi".into()));
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4714 -                         assert_eq!(**conv_inner, Selbri::Root("curmi".into()));
[INFO] [stdout] 4714 +                         assert_eq!(**conv_inner, Selbri::Root("curmi"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4714 -                         assert_eq!(**conv_inner, Selbri::Root("curmi".into()));
[INFO] [stdout] 4714 +                         assert_eq!(**conv_inner, Selbri::Root(<&str as Into<_>>::into("curmi")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> gerna/src/grammar_tests.rs:4786:42
[INFO] [stdout]      |
[INFO] [stdout] 4786 |             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4786 -             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout] 4786 +             assert_eq!(**m, Selbri::Root("menli"));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4786 -             assert_eq!(**m, Selbri::Root("menli".into()));
[INFO] [stdout] 4786 +             assert_eq!(**m, Selbri::Root(<&str as Into<_>>::into("menli")));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:18:38
[INFO] [stdout]    |
[INFO] [stdout] 18 |                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 18 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 18 +                 selbri: Selbri::Root("klama"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 18 +                 selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:26:38
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 26 +                 selbri: Selbri::Root("prami"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 26 +                 selbri: Selbri::Root(<&str as Into<_>>::into("prami")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:55:38
[INFO] [stdout]    |
[INFO] [stdout] 55 |                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 55 +                 selbri: Selbri::Root("klama"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 55 +                 selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:63:38
[INFO] [stdout]    |
[INFO] [stdout] 63 |                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 63 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 63 +                 selbri: Selbri::Root("prami"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 63 +                 selbri: Selbri::Root(<&str as Into<_>>::into("prami")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:71:38
[INFO] [stdout]    |
[INFO] [stdout] 71 |                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 71 -                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 71 +                 selbri: Selbri::Root("barda"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 71 +                 selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:93:34
[INFO] [stdout]    |
[INFO] [stdout] 93 |             selbri: Selbri::Root("barda".into()),
[INFO] [stdout]    |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 93 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 93 +             selbri: Selbri::Root("barda"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 93 +             selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/flattener_tests.rs:97:53
[INFO] [stdout]    |
[INFO] [stdout] 97 |                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout]    |                                                     ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 97 -                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 97 +                     inner: arena.alloc(Selbri::Root("gerku")),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 -                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 97 +                     inner: arena.alloc(Selbri::Root(<&str as Into<_>>::into("gerku"))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:102:46
[INFO] [stdout]     |
[INFO] [stdout] 102 |                         selbri: Selbri::Root("sutra".into()),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 102 -                         selbri: Selbri::Root("sutra".into()),
[INFO] [stdout] 102 +                         selbri: Selbri::Root("sutra"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 -                         selbri: Selbri::Root("sutra".into()),
[INFO] [stdout] 102 +                         selbri: Selbri::Root(<&str as Into<_>>::into("sutra")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:130:34
[INFO] [stdout]     |
[INFO] [stdout] 130 |             selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 130 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 130 +             selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 130 +             selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:136:46
[INFO] [stdout]     |
[INFO] [stdout] 136 |                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 136 -                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 136 +                         selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 -                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 136 +                         selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:137:86
[INFO] [stdout]     |
[INFO] [stdout] 137 |                         head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -                         head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 137 +                         head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 -                         head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 137 +                         head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:168:38
[INFO] [stdout]     |
[INFO] [stdout] 168 |                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 168 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 168 +                 selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 168 -                 selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 168 +                 selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:172:57
[INFO] [stdout]     |
[INFO] [stdout] 172 |                         inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 172 -                         inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 172 +                         inner: arena.alloc(Selbri::Root("gerku")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 172 -                         inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 172 +                         inner: arena.alloc(Selbri::Root(<&str as Into<_>>::into("gerku"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:177:50
[INFO] [stdout]     |
[INFO] [stdout] 177 | ...                   selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 177 -                             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 177 +                             selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 -                             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 177 +                             selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:192:38
[INFO] [stdout]     |
[INFO] [stdout] 192 |                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 192 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 192 +                 selbri: Selbri::Root("prami"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 -                 selbri: Selbri::Root("prami".into()),
[INFO] [stdout] 192 +                 selbri: Selbri::Root(<&str as Into<_>>::into("prami")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:193:78
[INFO] [stdout]     |
[INFO] [stdout] 193 |                 head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 193 -                 head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 193 +                 head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 -                 head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 193 +                 head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:194:78
[INFO] [stdout]     |
[INFO] [stdout] 194 |                 tail_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("do".into())]),
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 194 -                 tail_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("do".into())]),
[INFO] [stdout] 194 +                 tail_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("do")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 -                 tail_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("do".into())]),
[INFO] [stdout] 194 +                 tail_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("do"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:222:38
[INFO] [stdout]     |
[INFO] [stdout] 222 |                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 222 -                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 222 +                 selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 -                 selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 222 +                 selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:228:50
[INFO] [stdout]     |
[INFO] [stdout] 228 | ...                   selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 228 -                             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 228 +                             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 -                             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 228 +                             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:230:77
[INFO] [stdout]     |
[INFO] [stdout] 230 | ...                   .alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 230 -                                 .alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 230 +                                 .alloc_slice_fill_iter(vec![Sumti::ProSumti("mi")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 -                                 .alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 230 +                                 .alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:273:34
[INFO] [stdout]     |
[INFO] [stdout] 273 |             selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 273 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 273 +             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 273 +             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:275:51
[INFO] [stdout]     |
[INFO] [stdout] 275 |                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 275 +                 left: arena.alloc(Sumti::ProSumti("mi")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 275 +                 left: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("mi"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:278:52
[INFO] [stdout]     |
[INFO] [stdout] 278 |                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout]     |                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 278 +                 right: arena.alloc(Sumti::ProSumti("do")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 278 +                 right: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("do"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:328:34
[INFO] [stdout]     |
[INFO] [stdout] 328 |             selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 328 +             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 328 +             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:330:51
[INFO] [stdout]     |
[INFO] [stdout] 330 |                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 330 +                 left: arena.alloc(Sumti::ProSumti("mi")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 330 +                 left: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("mi"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:333:52
[INFO] [stdout]     |
[INFO] [stdout] 333 |                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout]     |                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 333 -                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 333 +                 right: arena.alloc(Sumti::ProSumti("do")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 333 -                 right: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 333 +                 right: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("do"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:361:34
[INFO] [stdout]     |
[INFO] [stdout] 361 |             selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 361 +             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 361 +             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:363:51
[INFO] [stdout]     |
[INFO] [stdout] 363 |                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout]     |                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 363 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 363 +                 left: arena.alloc(Sumti::ProSumti("mi")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 -                 left: arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 363 +                 left: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("mi"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:367:55
[INFO] [stdout]     |
[INFO] [stdout] 367 |                     left: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout]     |                                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 367 -                     left: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 367 +                     left: arena.alloc(Sumti::ProSumti("do")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 367 -                     left: arena.alloc(Sumti::ProSumti("do".into())),
[INFO] [stdout] 367 +                     left: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("do"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:370:56
[INFO] [stdout]     |
[INFO] [stdout] 370 |                     right: arena.alloc(Sumti::ProSumti("di".into())),
[INFO] [stdout]     |                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 370 -                     right: arena.alloc(Sumti::ProSumti("di".into())),
[INFO] [stdout] 370 +                     right: arena.alloc(Sumti::ProSumti("di")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 -                     right: arena.alloc(Sumti::ProSumti("di".into())),
[INFO] [stdout] 370 +                     right: arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("di"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:414:34
[INFO] [stdout]     |
[INFO] [stdout] 414 |             selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 414 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 414 +             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 414 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 414 +             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:418:45
[INFO] [stdout]     |
[INFO] [stdout] 418 |                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout]     |                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 418 -                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 418 +                 arena.alloc(Sumti::ProSumti("mi")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 418 -                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 418 +                 arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("mi"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:449:34
[INFO] [stdout]     |
[INFO] [stdout] 449 |             selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 449 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 449 +             selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 449 +             selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:453:49
[INFO] [stdout]     |
[INFO] [stdout] 453 |                 inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 453 -                 inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 453 +                 inner: arena.alloc(Selbri::Root("gerku")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 453 -                 inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 453 +                 inner: arena.alloc(Selbri::Root(<&str as Into<_>>::into("gerku"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:519:34
[INFO] [stdout]     |
[INFO] [stdout] 519 |             selbri: Selbri::Root("djica".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 519 -             selbri: Selbri::Root("djica".into()),
[INFO] [stdout] 519 +             selbri: Selbri::Root("djica"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 519 -             selbri: Selbri::Root("djica".into()),
[INFO] [stdout] 519 +             selbri: Selbri::Root(<&str as Into<_>>::into("djica")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:520:74
[INFO] [stdout]     |
[INFO] [stdout] 520 |             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 520 -             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 520 +             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 520 -             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 520 +             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:528:50
[INFO] [stdout]     |
[INFO] [stdout] 528 | ...                   selbri: Selbri::Root("gerku".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 528 -                             selbri: Selbri::Root("gerku".into()),
[INFO] [stdout] 528 +                             selbri: Selbri::Root("gerku"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 -                             selbri: Selbri::Root("gerku".into()),
[INFO] [stdout] 528 +                             selbri: Selbri::Root(<&str as Into<_>>::into("gerku")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:536:50
[INFO] [stdout]     |
[INFO] [stdout] 536 | ...                   selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 536 -                             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 536 +                             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 -                             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 536 +                             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:581:34
[INFO] [stdout]     |
[INFO] [stdout] 581 |             selbri: Selbri::Root("djica".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 581 -             selbri: Selbri::Root("djica".into()),
[INFO] [stdout] 581 +             selbri: Selbri::Root("djica"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 581 -             selbri: Selbri::Root("djica".into()),
[INFO] [stdout] 581 +             selbri: Selbri::Root(<&str as Into<_>>::into("djica")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:582:74
[INFO] [stdout]     |
[INFO] [stdout] 582 |             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 582 -             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 582 +             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi")]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 582 -             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti("mi".into())]),
[INFO] [stdout] 582 +             head_terms: arena.alloc_slice_fill_iter(vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:588:46
[INFO] [stdout]     |
[INFO] [stdout] 588 |                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 588 -                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 588 +                         selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 588 -                         selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 588 +                         selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:592:65
[INFO] [stdout]     |
[INFO] [stdout] 592 | ...                   inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 592 -                                 inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 592 +                                 inner: arena.alloc(Selbri::Root("gerku")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 592 -                                 inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 592 +                                 inner: arena.alloc(Selbri::Root(<&str as Into<_>>::into("gerku"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:597:58
[INFO] [stdout]     |
[INFO] [stdout] 597 | ...                   selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 597 -                                     selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 597 +                                     selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 597 -                                     selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 597 +                                     selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:638:34
[INFO] [stdout]     |
[INFO] [stdout] 638 |             selbri: Selbri::Root("klama".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 638 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 638 +             selbri: Selbri::Root("klama"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 638 -             selbri: Selbri::Root("klama".into()),
[INFO] [stdout] 638 +             selbri: Selbri::Root(<&str as Into<_>>::into("klama")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:642:53
[INFO] [stdout]     |
[INFO] [stdout] 642 |                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout]     |                                                     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 642 -                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 642 +                     inner: arena.alloc(Selbri::Root("gerku")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 642 -                     inner: arena.alloc(Selbri::Root("gerku".into())),
[INFO] [stdout] 642 +                     inner: arena.alloc(Selbri::Root(<&str as Into<_>>::into("gerku"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:647:46
[INFO] [stdout]     |
[INFO] [stdout] 647 |                         selbri: Selbri::Root("nelci".into()),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                         selbri: Selbri::Root("nelci".into()),
[INFO] [stdout] 647 +                         selbri: Selbri::Root("nelci"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 647 -                         selbri: Selbri::Root("nelci".into()),
[INFO] [stdout] 647 +                         selbri: Selbri::Root(<&str as Into<_>>::into("nelci")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:654:58
[INFO] [stdout]     |
[INFO] [stdout] 654 | ...                   selbri: Selbri::Root("bajra".into()),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 654 -                                     selbri: Selbri::Root("bajra".into()),
[INFO] [stdout] 654 +                                     selbri: Selbri::Root("bajra"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 -                                     selbri: Selbri::Root("bajra".into()),
[INFO] [stdout] 654 +                                     selbri: Selbri::Root(<&str as Into<_>>::into("bajra")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:701:34
[INFO] [stdout]     |
[INFO] [stdout] 701 |             selbri: Selbri::Root("barda".into()),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 701 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 701 +             selbri: Selbri::Root("barda"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 -             selbri: Selbri::Root("barda".into()),
[INFO] [stdout] 701 +             selbri: Selbri::Root(<&str as Into<_>>::into("barda")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:704:56
[INFO] [stdout]     |
[INFO] [stdout] 704 |                 ModalTag::Fio(arena.alloc(Selbri::Root("klama".into()))),
[INFO] [stdout]     |                                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 704 -                 ModalTag::Fio(arena.alloc(Selbri::Root("klama".into()))),
[INFO] [stdout] 704 +                 ModalTag::Fio(arena.alloc(Selbri::Root("klama"))),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 704 -                 ModalTag::Fio(arena.alloc(Selbri::Root("klama".into()))),
[INFO] [stdout] 704 +                 ModalTag::Fio(arena.alloc(Selbri::Root(<&str as Into<_>>::into("klama")))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/flattener_tests.rs:705:45
[INFO] [stdout]     |
[INFO] [stdout] 705 |                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout]     |                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 705 -                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 705 +                 arena.alloc(Sumti::ProSumti("mi")),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 705 -                 arena.alloc(Sumti::ProSumti("mi".into())),
[INFO] [stdout] 705 +                 arena.alloc(Sumti::ProSumti(<&str as Into<_>>::into("mi"))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/pipeline_tests.rs:39:48
[INFO] [stdout]    |
[INFO] [stdout] 39 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]    |                                                ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 39 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 39 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 39 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 39 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/pipeline_tests.rs:42:49
[INFO] [stdout]    |
[INFO] [stdout] 42 |             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout]    |                                                 ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 42 +             assert_eq!(**right, Sumti::ProSumti("do"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 42 +             assert_eq!(**right, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/pipeline_tests.rs:46:39
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 46 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 46 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 46 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:173:39
[INFO] [stdout]     |
[INFO] [stdout] 173 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 173 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 173 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 173 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:197:22
[INFO] [stdout]     |
[INFO] [stdout] 197 |         Selbri::Root("klama".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 197 -         Selbri::Root("klama".into())
[INFO] [stdout] 197 +         Selbri::Root("klama")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 -         Selbri::Root("klama".into())
[INFO] [stdout] 197 +         Selbri::Root(<&str as Into<_>>::into("klama"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:201:22
[INFO] [stdout]     |
[INFO] [stdout] 201 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 201 -         Selbri::Root("prami".into())
[INFO] [stdout] 201 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 -         Selbri::Root("prami".into())
[INFO] [stdout] 201 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:218:48
[INFO] [stdout]     |
[INFO] [stdout] 218 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 218 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 218 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 218 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 218 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:294:39
[INFO] [stdout]     |
[INFO] [stdout] 294 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 294 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 294 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:318:75
[INFO] [stdout]     |
[INFO] [stdout] 318 |                     assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 318 +                     assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti("ce'u".into()));
[INFO] [stdout] 318 +                     assert_eq!(inner_bridi.head_terms[0], Sumti::ProSumti(<&str as Into<_>>::into("ce'u")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:402:47
[INFO] [stdout]     |
[INFO] [stdout] 402 |             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 402 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 402 +             assert_eq!(**selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 -             assert_eq!(**selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 402 +             assert_eq!(**selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:403:49
[INFO] [stdout]     |
[INFO] [stdout] 403 |             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 403 -             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout] 403 +             assert_eq!(**inner, Sumti::ProSumti("do"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 -             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout] 403 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:440:46
[INFO] [stdout]     |
[INFO] [stdout] 440 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 440 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 440 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 440 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:444:39
[INFO] [stdout]     |
[INFO] [stdout] 444 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 444 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 444 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 444 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:457:46
[INFO] [stdout]     |
[INFO] [stdout] 457 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 457 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 457 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 457 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 457 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:513:40
[INFO] [stdout]     |
[INFO] [stdout] 513 |     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 513 -     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 513 +     assert_eq!(s1.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 -     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 513 +     assert_eq!(s1.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/pipeline_tests.rs:515:40
[INFO] [stdout]     |
[INFO] [stdout] 515 |     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 515 -     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 515 +     assert_eq!(s2.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 515 -     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 515 +     assert_eq!(s2.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:58:39
[INFO] [stdout]    |
[INFO] [stdout] 58 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 58 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 58 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 58 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:59:51
[INFO] [stdout]    |
[INFO] [stdout] 59 |     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout]    |                                                   ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 59 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 59 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi")]);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 59 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:60:51
[INFO] [stdout]    |
[INFO] [stdout] 60 |     assert_eq!(s.tail_terms, vec![Sumti::ProSumti("do".into())]);
[INFO] [stdout]    |                                                   ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -     assert_eq!(s.tail_terms, vec![Sumti::ProSumti("do".into())]);
[INFO] [stdout] 60 +     assert_eq!(s.tail_terms, vec![Sumti::ProSumti("do")]);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -     assert_eq!(s.tail_terms, vec![Sumti::ProSumti("do".into())]);
[INFO] [stdout] 60 +     assert_eq!(s.tail_terms, vec![Sumti::ProSumti(<&str as Into<_>>::into("do"))]);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:69:39
[INFO] [stdout]    |
[INFO] [stdout] 69 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 69 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 69 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 69 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |         Selbri::Root("prami".into())
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 91 -         Selbri::Root("prami".into())
[INFO] [stdout] 91 +         Selbri::Root("prami")
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 -         Selbri::Root("prami".into())
[INFO] [stdout] 91 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:95:22
[INFO] [stdout]    |
[INFO] [stdout] 95 |         Selbri::Root("prami".into())
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 95 -         Selbri::Root("prami".into())
[INFO] [stdout] 95 +         Selbri::Root("prami")
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 -         Selbri::Root("prami".into())
[INFO] [stdout] 95 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> gerna/src/integration_tests.rs:99:30
[INFO] [stdout]    |
[INFO] [stdout] 99 |         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout]    |                              ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout] 99 +         vec![Sumti::ProSumti("mi")]
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout] 99 +         vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:103:30
[INFO] [stdout]     |
[INFO] [stdout] 103 |         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout]     |                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 103 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 103 +         vec![Sumti::ProSumti("do")]
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 103 +         vec![Sumti::ProSumti(<&str as Into<_>>::into("do"))]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:125:46
[INFO] [stdout]     |
[INFO] [stdout] 125 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 125 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 125 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 125 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 125 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:150:46
[INFO] [stdout]     |
[INFO] [stdout] 150 |             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 150 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 150 +             assert_eq!(**inner, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 150 -             assert_eq!(**inner, Selbri::Root("gerku".into()));
[INFO] [stdout] 150 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:154:39
[INFO] [stdout]     |
[INFO] [stdout] 154 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 154 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 154 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 154 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:164:47
[INFO] [stdout]     |
[INFO] [stdout] 164 |     assert_eq!(s.head_terms, vec![Sumti::Name("djan".into())]);
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -     assert_eq!(s.head_terms, vec![Sumti::Name("djan".into())]);
[INFO] [stdout] 164 +     assert_eq!(s.head_terms, vec![Sumti::Name("djan")]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -     assert_eq!(s.head_terms, vec![Sumti::Name("djan".into())]);
[INFO] [stdout] 164 +     assert_eq!(s.head_terms, vec![Sumti::Name(<&str as Into<_>>::into("djan"))]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:165:39
[INFO] [stdout]     |
[INFO] [stdout] 165 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 165 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 165 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 165 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:178:49
[INFO] [stdout]     |
[INFO] [stdout] 178 |             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout] 178 +             assert_eq!(**inner, Sumti::ProSumti("do"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -             assert_eq!(**inner, Sumti::ProSumti("do".into()));
[INFO] [stdout] 178 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:184:49
[INFO] [stdout]     |
[INFO] [stdout] 184 |             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 184 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 184 +             assert_eq!(**inner, Sumti::ProSumti("mi"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 -             assert_eq!(**inner, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 184 +             assert_eq!(**inner, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:198:39
[INFO] [stdout]     |
[INFO] [stdout] 198 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 198 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 198 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:207:39
[INFO] [stdout]     |
[INFO] [stdout] 207 |     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 207 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 207 +     assert_eq!(s.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 -     assert_eq!(s.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 207 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:226:39
[INFO] [stdout]     |
[INFO] [stdout] 226 |     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 226 -     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout] 226 +     assert_eq!(s.selbri, Selbri::Root("citka"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 226 -     assert_eq!(s.selbri, Selbri::Root("citka".into()));
[INFO] [stdout] 226 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("citka")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:227:51
[INFO] [stdout]     |
[INFO] [stdout] 227 |     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout]     |                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 227 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 227 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi")]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 -     assert_eq!(s.head_terms, vec![Sumti::ProSumti("mi".into())]);
[INFO] [stdout] 227 +     assert_eq!(s.head_terms, vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:232:46
[INFO] [stdout]     |
[INFO] [stdout] 232 |             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 232 -             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout] 232 +             assert_eq!(**inner, Selbri::Root("plise"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 -             assert_eq!(**inner, Selbri::Root("plise".into()));
[INFO] [stdout] 232 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("plise")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:247:46
[INFO] [stdout]     |
[INFO] [stdout] 247 |             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 247 -             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout] 247 +             assert_eq!(**inner, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 247 -             assert_eq!(**inner, Selbri::Root("prami".into()));
[INFO] [stdout] 247 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:272:49
[INFO] [stdout]     |
[INFO] [stdout] 272 |             assert_eq!(**modifier, Selbri::Root("sutra".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -             assert_eq!(**modifier, Selbri::Root("sutra".into()));
[INFO] [stdout] 272 +             assert_eq!(**modifier, Selbri::Root("sutra"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -             assert_eq!(**modifier, Selbri::Root("sutra".into()));
[INFO] [stdout] 272 +             assert_eq!(**modifier, Selbri::Root(<&str as Into<_>>::into("sutra")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:273:45
[INFO] [stdout]     |
[INFO] [stdout] 273 |             assert_eq!(**head, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 273 -             assert_eq!(**head, Selbri::Root("gerku".into()));
[INFO] [stdout] 273 +             assert_eq!(**head, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 -             assert_eq!(**head, Selbri::Root("gerku".into()));
[INFO] [stdout] 273 +             assert_eq!(**head, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:286:42
[INFO] [stdout]     |
[INFO] [stdout] 286 |             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 286 -             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout] 286 +             assert_eq!(**a, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 286 -             assert_eq!(**a, Selbri::Root("barda".into()));
[INFO] [stdout] 286 +             assert_eq!(**a, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:289:50
[INFO] [stdout]     |
[INFO] [stdout] 289 |                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 289 -                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout] 289 +                     assert_eq!(**b, Selbri::Root("sutra"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 289 -                     assert_eq!(**b, Selbri::Root("sutra".into()));
[INFO] [stdout] 289 +                     assert_eq!(**b, Selbri::Root(<&str as Into<_>>::into("sutra")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:290:50
[INFO] [stdout]     |
[INFO] [stdout] 290 |                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 290 -                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout] 290 +                     assert_eq!(**c, Selbri::Root("gerku"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 -                     assert_eq!(**c, Selbri::Root("gerku".into()));
[INFO] [stdout] 290 +                     assert_eq!(**c, Selbri::Root(<&str as Into<_>>::into("gerku")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:307:45
[INFO] [stdout]     |
[INFO] [stdout] 307 |             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout] 307 +             assert_eq!(**core, Selbri::Root("nelci"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -             assert_eq!(**core, Selbri::Root("nelci".into()));
[INFO] [stdout] 307 +             assert_eq!(**core, Selbri::Root(<&str as Into<_>>::into("nelci")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:320:45
[INFO] [stdout]     |
[INFO] [stdout] 320 |             assert_eq!(**core, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 320 -             assert_eq!(**core, Selbri::Root("klama".into()));
[INFO] [stdout] 320 +             assert_eq!(**core, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 320 -             assert_eq!(**core, Selbri::Root("klama".into()));
[INFO] [stdout] 320 +             assert_eq!(**core, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:354:45
[INFO] [stdout]     |
[INFO] [stdout] 354 |             assert_eq!(**left, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 354 -             assert_eq!(**left, Selbri::Root("barda".into()));
[INFO] [stdout] 354 +             assert_eq!(**left, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 -             assert_eq!(**left, Selbri::Root("barda".into()));
[INFO] [stdout] 354 +             assert_eq!(**left, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:356:46
[INFO] [stdout]     |
[INFO] [stdout] 356 |             assert_eq!(**right, Selbri::Root("xunre".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 356 -             assert_eq!(**right, Selbri::Root("xunre".into()));
[INFO] [stdout] 356 +             assert_eq!(**right, Selbri::Root("xunre"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 -             assert_eq!(**right, Selbri::Root("xunre".into()));
[INFO] [stdout] 356 +             assert_eq!(**right, Selbri::Root(<&str as Into<_>>::into("xunre")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:572:22
[INFO] [stdout]     |
[INFO] [stdout] 572 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 572 -         Selbri::Root("prami".into())
[INFO] [stdout] 572 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 572 -         Selbri::Root("prami".into())
[INFO] [stdout] 572 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:583:22
[INFO] [stdout]     |
[INFO] [stdout] 583 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 583 -         Selbri::Root("prami".into())
[INFO] [stdout] 583 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 583 -         Selbri::Root("prami".into())
[INFO] [stdout] 583 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:587:30
[INFO] [stdout]     |
[INFO] [stdout] 587 |         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout]     |                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 587 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 587 +         vec![Sumti::ProSumti("do")]
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 587 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 587 +         vec![Sumti::ProSumti(<&str as Into<_>>::into("do"))]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:599:22
[INFO] [stdout]     |
[INFO] [stdout] 599 |         Selbri::Root("sutra".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 599 -         Selbri::Root("sutra".into())
[INFO] [stdout] 599 +         Selbri::Root("sutra")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 599 -         Selbri::Root("sutra".into())
[INFO] [stdout] 599 +         Selbri::Root(<&str as Into<_>>::into("sutra"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:604:46
[INFO] [stdout]     |
[INFO] [stdout] 604 |             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 604 -             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout] 604 +             assert_eq!(**inner, Selbri::Root("mlatu"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 604 -             assert_eq!(**inner, Selbri::Root("mlatu".into()));
[INFO] [stdout] 604 +             assert_eq!(**inner, Selbri::Root(<&str as Into<_>>::into("mlatu")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:617:22
[INFO] [stdout]     |
[INFO] [stdout] 617 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 617 -         Selbri::Root("prami".into())
[INFO] [stdout] 617 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 617 -         Selbri::Root("prami".into())
[INFO] [stdout] 617 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:621:30
[INFO] [stdout]     |
[INFO] [stdout] 621 |         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout]     |                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 621 -         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout] 621 +         vec![Sumti::ProSumti("mi")]
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 621 -         vec![Sumti::ProSumti("mi".into())]
[INFO] [stdout] 621 +         vec![Sumti::ProSumti(<&str as Into<_>>::into("mi"))]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:625:30
[INFO] [stdout]     |
[INFO] [stdout] 625 |         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout]     |                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 625 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 625 +         vec![Sumti::ProSumti("do")]
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 625 -         vec![Sumti::ProSumti("do".into())]
[INFO] [stdout] 625 +         vec![Sumti::ProSumti(<&str as Into<_>>::into("do"))]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:640:22
[INFO] [stdout]     |
[INFO] [stdout] 640 |         Selbri::Root("sutra".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 640 -         Selbri::Root("sutra".into())
[INFO] [stdout] 640 +         Selbri::Root("sutra")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 640 -         Selbri::Root("sutra".into())
[INFO] [stdout] 640 +         Selbri::Root(<&str as Into<_>>::into("sutra"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:653:22
[INFO] [stdout]     |
[INFO] [stdout] 653 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 653 -         Selbri::Root("prami".into())
[INFO] [stdout] 653 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 653 -         Selbri::Root("prami".into())
[INFO] [stdout] 653 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:657:22
[INFO] [stdout]     |
[INFO] [stdout] 657 |         Selbri::Root("nelci".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 657 -         Selbri::Root("nelci".into())
[INFO] [stdout] 657 +         Selbri::Root("nelci")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 657 -         Selbri::Root("nelci".into())
[INFO] [stdout] 657 +         Selbri::Root(<&str as Into<_>>::into("nelci"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:698:48
[INFO] [stdout]     |
[INFO] [stdout] 698 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 698 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 698 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 698 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 698 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:701:49
[INFO] [stdout]     |
[INFO] [stdout] 701 |             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 701 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 701 +             assert_eq!(**right, Sumti::ProSumti("do"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 -             assert_eq!(**right, Sumti::ProSumti("do".into()));
[INFO] [stdout] 701 +             assert_eq!(**right, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:705:39
[INFO] [stdout]     |
[INFO] [stdout] 705 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 705 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 705 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 705 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 705 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:805:39
[INFO] [stdout]     |
[INFO] [stdout] 805 |     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 805 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 805 +     assert_eq!(s.selbri, Selbri::Root("barda"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 805 -     assert_eq!(s.selbri, Selbri::Root("barda".into()));
[INFO] [stdout] 805 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("barda")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:831:22
[INFO] [stdout]     |
[INFO] [stdout] 831 |         Selbri::Root("klama".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 831 -         Selbri::Root("klama".into())
[INFO] [stdout] 831 +         Selbri::Root("klama")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 831 -         Selbri::Root("klama".into())
[INFO] [stdout] 831 +         Selbri::Root(<&str as Into<_>>::into("klama"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:835:22
[INFO] [stdout]     |
[INFO] [stdout] 835 |         Selbri::Root("prami".into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 835 -         Selbri::Root("prami".into())
[INFO] [stdout] 835 +         Selbri::Root("prami")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 835 -         Selbri::Root("prami".into())
[INFO] [stdout] 835 +         Selbri::Root(<&str as Into<_>>::into("prami"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:852:48
[INFO] [stdout]     |
[INFO] [stdout] 852 |             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 852 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 852 +             assert_eq!(**left, Sumti::ProSumti("mi"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 852 -             assert_eq!(**left, Sumti::ProSumti("mi".into()));
[INFO] [stdout] 852 +             assert_eq!(**left, Sumti::ProSumti(<&str as Into<_>>::into("mi")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:861:62
[INFO] [stdout]     |
[INFO] [stdout] 861 |                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 861 -                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout] 861 +                     assert_eq!(**inner_left, Sumti::ProSumti("do"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 861 -                     assert_eq!(**inner_left, Sumti::ProSumti("do".into()));
[INFO] [stdout] 861 +                     assert_eq!(**inner_left, Sumti::ProSumti(<&str as Into<_>>::into("do")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:862:63
[INFO] [stdout]     |
[INFO] [stdout] 862 |                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 862 -                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout] 862 +                     assert_eq!(**inner_right, Sumti::ProSumti("di"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 862 -                     assert_eq!(**inner_right, Sumti::ProSumti("di".into()));
[INFO] [stdout] 862 +                     assert_eq!(**inner_right, Sumti::ProSumti(<&str as Into<_>>::into("di")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:889:39
[INFO] [stdout]     |
[INFO] [stdout] 889 |     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 889 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 889 +     assert_eq!(s.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 889 -     assert_eq!(s.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 889 +     assert_eq!(s.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:929:40
[INFO] [stdout]     |
[INFO] [stdout] 929 |     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 929 -     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 929 +     assert_eq!(s1.selbri, Selbri::Root("klama"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 929 -     assert_eq!(s1.selbri, Selbri::Root("klama".into()));
[INFO] [stdout] 929 +     assert_eq!(s1.selbri, Selbri::Root(<&str as Into<_>>::into("klama")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> gerna/src/integration_tests.rs:932:40
[INFO] [stdout]     |
[INFO] [stdout] 932 |     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 932 -     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 932 +     assert_eq!(s2.selbri, Selbri::Root("prami"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 932 -     assert_eq!(s2.selbri, Selbri::Root("prami".into()));
[INFO] [stdout] 932 +     assert_eq!(s2.selbri, Selbri::Root(<&str as Into<_>>::into("prami")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `gerna` (lib test) due to 204 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] warning: unused dependency `gerna`
[INFO] [stderr]  --> smuni/Cargo.toml:8:1
[INFO] [stderr]   |
[INFO] [stderr] 8 | gerna = { path = "../gerna" }
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `gerna`
[INFO] [stderr] warning: `smuni` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a", kill_on_drop: false }`
[INFO] [stdout] fe4746dc53948ec514d7a8a66eec2550e41604161494265f3d074f705be0a80a
