[INFO] fetching crate webmachine-rust 0.6.4...
[INFO] checking webmachine-rust-0.6.4 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate webmachine-rust 0.6.4 into /workspace/builds/worker-2-tc2/source
[INFO] started tweaking crates.io crate webmachine-rust 0.6.4
[INFO] finished tweaking crates.io crate webmachine-rust 0.6.4
[INFO] tweaked toml for crates.io crate webmachine-rust 0.6.4 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate webmachine-rust 0.6.4 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate webmachine-rust 0.6.4 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:81:12
[INFO] [stderr]    |
[INFO] [stderr] 81 | homepage = "https://github.com/rholshausen/webmachine-rust"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 86 | repository = "https://github.com/rholshausen/webmachine-rust"
[INFO] [stderr]    |              ------------------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `webmachine-rust` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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] e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1
[INFO] running `Command { std: "docker" "start" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1", 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" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1", 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" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:81:12
[INFO] [stderr]    |
[INFO] [stderr] 81 | homepage = "https://github.com/rholshausen/webmachine-rust"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 86 | repository = "https://github.com/rholshausen/webmachine-rust"
[INFO] [stderr]    |              ------------------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `webmachine-rust` (manifest) generated 1 warning
[INFO] [stderr]    Compiling libc v0.2.182
[INFO] [stderr]     Checking pin-project-lite v0.2.14
[INFO] [stderr]    Compiling slab v0.4.9
[INFO] [stderr]     Checking http v1.4.0
[INFO] [stderr]     Checking tracing-core v0.1.36
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling httparse v1.9.4
[INFO] [stderr]     Checking indexmap v2.2.6
[INFO] [stderr]    Compiling syn v2.0.87
[INFO] [stderr]    Compiling anyhow v1.0.102
[INFO] [stderr]     Checking log v0.4.22
[INFO] [stderr]     Checking anstream v0.6.21
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]     Checking either v1.13.0
[INFO] [stderr]     Checking serde_json v1.0.149
[INFO] [stderr]     Checking env_filter v1.0.0
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]     Checking env_logger v0.11.9
[INFO] [stderr]     Checking http-body v1.0.1
[INFO] [stderr]     Checking http-body-util v0.1.3
[INFO] [stderr]     Checking chrono v0.4.44
[INFO] [stderr]     Checking expectest v0.12.0
[INFO] [stderr]     Checking parking_lot_core v0.9.10
[INFO] [stderr]     Checking signal-hook-registry v1.4.2
[INFO] [stderr]     Checking mio v1.1.1
[INFO] [stderr]     Checking socket2 v0.6.2
[INFO] [stderr]     Checking parking_lot v0.12.3
[INFO] [stderr]    Compiling tokio-macros v2.6.1
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]    Compiling futures-macro v0.3.32
[INFO] [stderr]    Compiling test-log-macros v0.2.19
[INFO] [stderr]    Compiling async-trait v0.1.89
[INFO] [stderr]     Checking test-log v0.2.19
[INFO] [stderr]     Checking tokio v1.49.0
[INFO] [stderr]     Checking futures-util v0.3.32
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking futures-executor v0.3.32
[INFO] [stderr]     Checking futures v0.3.32
[INFO] [stderr]     Checking tokio-util v0.7.11
[INFO] [stderr]     Checking h2 v0.4.5
[INFO] [stderr]     Checking hyper v1.8.1
[INFO] [stderr]     Checking hyper-util v0.1.20
[INFO] [stderr]     Checking webmachine-rust v0.6.4 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `bytes::Bytes`
[INFO] [stdout]     --> src/lib.rs:1519:43
[INFO] [stdout]      |
[INFO] [stdout] 1519 |     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout]      |                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 1519 -     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout] 1519 +     Some(body) => response.body(Full::new(body)),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1519 -     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout] 1519 +     Some(body) => response.body(Full::new(<bytes::Bytes as Into<_>>::into(body))),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation.rs:329:23
[INFO] [stdout]     |
[INFO] [stdout] 329 |         charsets.push(h!("ISO-8859-1"));
[INFO] [stdout]     |                       ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation.rs:419:24
[INFO] [stdout]     |
[INFO] [stdout] 419 |         encodings.push(h!("identity"));
[INFO] [stdout]     |                        -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1453:22
[INFO] [stdout]      |
[INFO] [stdout] 1453 |     vary_header.push(h!("Accept-Language"));
[INFO] [stdout]      |                      --------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1456:22
[INFO] [stdout]      |
[INFO] [stdout] 1456 |     vary_header.push(h!("Accept-Charset"));
[INFO] [stdout]      |                      -------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1459:22
[INFO] [stdout]      |
[INFO] [stdout] 1459 |     vary_header.push(h!("Accept-Encoding"));
[INFO] [stdout]      |                      --------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1462:22
[INFO] [stdout]      |
[INFO] [stdout] 1462 |     vary_header.push(h!("Accept"));
[INFO] [stdout]      |                      ------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `webmachine-rust` (lib) due to 7 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `bytes::Bytes`
[INFO] [stdout]     --> src/lib.rs:1519:43
[INFO] [stdout]      |
[INFO] [stdout] 1519 |     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout]      |                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 1519 -     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout] 1519 +     Some(body) => response.body(Full::new(body)),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1519 -     Some(body) => response.body(Full::new(body.into())),
[INFO] [stdout] 1519 +     Some(body) => response.body(Full::new(<bytes::Bytes as Into<_>>::into(body))),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/context.rs:444:60
[INFO] [stdout]     |
[INFO] [stdout] 444 |           headers: hashmap!{ "HeaderA".to_string() => vec![h!("*")] },
[INFO] [stdout]     |                                                            ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/context.rs:455:60
[INFO] [stdout]     |
[INFO] [stdout] 455 |           headers: hashmap!{ "HeaderA".to_string() => vec![h!("*"), h!("other")]},
[INFO] [stdout]     |                                                            ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/context.rs:455:69
[INFO] [stdout]     |
[INFO] [stdout] 455 |           headers: hashmap!{ "HeaderA".to_string() => vec![h!("*"), h!("other")]},
[INFO] [stdout]     |                                                                     ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation.rs:329:23
[INFO] [stdout]     |
[INFO] [stdout] 329 |         charsets.push(h!("ISO-8859-1"));
[INFO] [stdout]     |                       ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation.rs:419:24
[INFO] [stdout]     |
[INFO] [stdout] 419 |         encodings.push(h!("identity"));
[INFO] [stdout]     |                        -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1453:22
[INFO] [stdout]      |
[INFO] [stdout] 1453 |     vary_header.push(h!("Accept-Language"));
[INFO] [stdout]      |                      --------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1456:22
[INFO] [stdout]      |
[INFO] [stdout] 1456 |     vary_header.push(h!("Accept-Charset"));
[INFO] [stdout]      |                      -------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1459:22
[INFO] [stdout]      |
[INFO] [stdout] 1459 |     vary_header.push(h!("Accept-Encoding"));
[INFO] [stdout]      |                      --------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/lib.rs:1462:22
[INFO] [stdout]      |
[INFO] [stdout] 1462 |     vary_header.push(h!("Accept"));
[INFO] [stdout]      |                      ------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:471:86
[INFO] [stdout]     |
[INFO] [stdout] 471 |   expect(context.response.headers.get("Content-Type").unwrap()).to(be_equal_to(&vec![h!("application/xml;charset=ISO-8859-1")]));
[INFO] [stdout]     |                                                                                      ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:510:102
[INFO] [stdout]     |
[INFO] [stdout] 510 |   expect(context.response.headers).to(be_equal_to(btreemap! { "Content-Language".to_string() => vec![h!("en")] }));
[INFO] [stdout]     |                                                                                                      -------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:518:46
[INFO] [stdout]     |
[INFO] [stdout] 518 |         "Accept-Charset".to_string() => vec![h!("iso-8859-5"), h!("iso-8859-1;q=0")]
[INFO] [stdout]     |                                              ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:518:64
[INFO] [stdout]     |
[INFO] [stdout] 518 |         "Accept-Charset".to_string() => vec![h!("iso-8859-5"), h!("iso-8859-1;q=0")]
[INFO] [stdout]     |                                                                -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:537:46
[INFO] [stdout]     |
[INFO] [stdout] 537 |         "Accept-Charset".to_string() => vec![h!("UTF-8"), h!("iso-8859-1;q=0")]
[INFO] [stdout]     |                                              ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:537:59
[INFO] [stdout]     |
[INFO] [stdout] 537 |         "Accept-Charset".to_string() => vec![h!("UTF-8"), h!("iso-8859-1;q=0")]
[INFO] [stdout]     |                                                           -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:550:86
[INFO] [stdout]     |
[INFO] [stdout] 550 |   expect(context.response.headers.get("Content-Type").unwrap()).to(be_equal_to(&vec![h!("application/json;charset=UTF-8")]));
[INFO] [stdout]     |                                                                                      ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:558:47
[INFO] [stdout]     |
[INFO] [stdout] 558 |         "Accept-Encoding".to_string() => vec![h!("compress"), h!("*;q=0")]
[INFO] [stdout]     |                                               -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:558:63
[INFO] [stdout]     |
[INFO] [stdout] 558 |         "Accept-Encoding".to_string() => vec![h!("compress"), h!("*;q=0")]
[INFO] [stdout]     |                                                               ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:589:82
[INFO] [stdout]     |
[INFO] [stdout] 589 |   expect!(context.response.headers.get("Content-Type")).to(be_some().value(&vec![h!("application/json;charset=ISO-8859-1")]));
[INFO] [stdout]     |                                                                                  ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:590:74
[INFO] [stdout]     |
[INFO] [stdout] 590 |   expect!(context.response.headers.get("Vary")).to(be_some().value(&vec![h!("HEADER-A"), h!("HEADER-B")]));
[INFO] [stdout]     |                                                                          -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:590:90
[INFO] [stdout]     |
[INFO] [stdout] 590 |   expect!(context.response.headers.get("Vary")).to(be_some().value(&vec![h!("HEADER-A"), h!("HEADER-B")]));
[INFO] [stdout]     |                                                                                          -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:614:40
[INFO] [stdout]     |
[INFO] [stdout] 614 |         "If-Match".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                        ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:646:36
[INFO] [stdout]     |
[INFO] [stdout] 646 |     "Location".to_string() => vec![h!("http://go.away.com/to/here")]
[INFO] [stdout]     |                                    -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:707:36
[INFO] [stdout]     |
[INFO] [stdout] 707 |     "Location".to_string() => vec![h!("http://go.away.com/to/here")]
[INFO] [stdout]     |                                    -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:728:36
[INFO] [stdout]     |
[INFO] [stdout] 728 |     "Location".to_string() => vec![h!("http://go.away.com/to/here")]
[INFO] [stdout]     |                                    -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:794:40
[INFO] [stdout]     |
[INFO] [stdout] 794 |         "If-Match".to_string() => vec![h!("\"1234567891\"")]
[INFO] [stdout]     |                                        -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:814:40
[INFO] [stdout]     |
[INFO] [stdout] 814 |         "If-Match".to_string() => vec![h!("W/\"1234567891\"")]
[INFO] [stdout]     |                                        ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:837:51
[INFO] [stdout]     |
[INFO] [stdout] 837 |         "If-Unmodified-Since".to_string() => vec![h!(&*format!("\"{}\"", header_datetime.to_rfc2822()))]
[INFO] [stdout]     |                                                   ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:863:45
[INFO] [stdout]     |
[INFO] [stdout] 863 |         "If-None-Match".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                             ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:884:45
[INFO] [stdout]     |
[INFO] [stdout] 884 |         "If-None-Match".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                             ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:905:45
[INFO] [stdout]     |
[INFO] [stdout] 905 |         "If-None-Match".to_string() => vec![h!("W/\"1234567890\""), h!("W/\"1234567891\"")]
[INFO] [stdout]     |                                             ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:905:69
[INFO] [stdout]     |
[INFO] [stdout] 905 |         "If-None-Match".to_string() => vec![h!("W/\"1234567890\""), h!("W/\"1234567891\"")]
[INFO] [stdout]     |                                                                     ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:926:45
[INFO] [stdout]     |
[INFO] [stdout] 926 |         "If-None-Match".to_string() => vec![h!("\"1234567890\""), h!("\"1234567891\"")]
[INFO] [stdout]     |                                             -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:926:67
[INFO] [stdout]     |
[INFO] [stdout] 926 |         "If-None-Match".to_string() => vec![h!("\"1234567890\""), h!("\"1234567891\"")]
[INFO] [stdout]     |                                                                   -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/tests.rs:949:49
[INFO] [stdout]     |
[INFO] [stdout] 949 |         "If-Modified-Since".to_string() => vec![h!(&*format!("\"{}\"", header_datetime.to_rfc2822()))]
[INFO] [stdout]     |                                                 ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/tests.rs:1079:36
[INFO] [stdout]      |
[INFO] [stdout] 1079 |     "Location".to_string() => vec![h!("/base/path/new/path")]
[INFO] [stdout]      |                                    ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/headers.rs:245:43
[INFO] [stdout]      |
[INFO] [stdout]  244 | macro_rules! h {
[INFO] [stdout]  245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/tests.rs:1152:36
[INFO] [stdout]      |
[INFO] [stdout] 1152 |     "Location".to_string() => vec![h!("/new/path")]
[INFO] [stdout]      |                                    --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:114:34
[INFO] [stdout]     |
[INFO] [stdout] 114 |   expect!(sort_media_types(&vec![h!("text/plain")])).to(be_equal_to(vec![h!("text/plain")]));
[INFO] [stdout]     |                                  ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:114:74
[INFO] [stdout]     |
[INFO] [stdout] 114 |   expect!(sort_media_types(&vec![h!("text/plain")])).to(be_equal_to(vec![h!("text/plain")]));
[INFO] [stdout]     |                                                                          ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:115:34
[INFO] [stdout]     |
[INFO] [stdout] 115 |   expect!(sort_media_types(&vec![h!("text/plain"), h!("text/html")])).to(be_equal_to(vec![h!("text/plain"), h!("text/html")]));
[INFO] [stdout]     |                                  ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:115:52
[INFO] [stdout]     |
[INFO] [stdout] 115 |   expect!(sort_media_types(&vec![h!("text/plain"), h!("text/html")])).to(be_equal_to(vec![h!("text/plain"), h!("text/html")]));
[INFO] [stdout]     |                                                    --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:115:91
[INFO] [stdout]     |
[INFO] [stdout] 115 |   expect!(sort_media_types(&vec![h!("text/plain"), h!("text/html")])).to(be_equal_to(vec![h!("text/plain"), h!("text/html")]));
[INFO] [stdout]     |                                                                                           ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:115:109
[INFO] [stdout]     |
[INFO] [stdout] 115 |   expect!(sort_media_types(&vec![h!("text/plain"), h!("text/html")])).to(be_equal_to(vec![h!("text/plain"), h!("text/html")]));
[INFO] [stdout]     |                                                                                                             --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:116:34
[INFO] [stdout]     |
[INFO] [stdout] 116 |   expect!(sort_media_types(&vec![h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*")]));
[INFO] [stdout]     |                                  ------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:116:48
[INFO] [stdout]     |
[INFO] [stdout] 116 |   expect!(sort_media_types(&vec![h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*")]));
[INFO] [stdout]     |                                                --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:116:87
[INFO] [stdout]     |
[INFO] [stdout] 116 |   expect!(sort_media_types(&vec![h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*")]));
[INFO] [stdout]     |                                                                                       --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:116:104
[INFO] [stdout]     |
[INFO] [stdout] 116 |   expect!(sort_media_types(&vec![h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*")]));
[INFO] [stdout]     |                                                                                                        ------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:34
[INFO] [stdout]     |
[INFO] [stdout] 117 |   expect!(sort_media_types(&vec![h!("*/*"), h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*"), h!(...
[INFO] [stdout]     |                                  --------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:45
[INFO] [stdout]     |
[INFO] [stdout] 117 |   expect!(sort_media_types(&vec![h!("*/*"), h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*"), h!(...
[INFO] [stdout]     |                                             ------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:59
[INFO] [stdout]     |
[INFO] [stdout] 117 |   expect!(sort_media_types(&vec![h!("*/*"), h!("text/*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*"), h!(...
[INFO] [stdout]     |                                                           --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:98
[INFO] [stdout]     |
[INFO] [stdout] 117 | ...*"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/*"), h!("*/*")]));
[INFO] [stdout]     |                                                --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:115
[INFO] [stdout]     |
[INFO] [stdout] 117 | ...ml")])).to(be_equal_to(vec![h!("text/html"), h!("text/*"), h!("*/*")]));
[INFO] [stdout]     |                                                 ------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:117:129
[INFO] [stdout]     |
[INFO] [stdout] 117 | ...e_equal_to(vec![h!("text/html"), h!("text/*"), h!("*/*")]));
[INFO] [stdout]     |                                                   --------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:122:34
[INFO] [stdout]     |
[INFO] [stdout] 122 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2")])).to(be_equal_to(vec![h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                  ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:122:80
[INFO] [stdout]     |
[INFO] [stdout] 122 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2")])).to(be_equal_to(vec![h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                                                                ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:123:34
[INFO] [stdout]     |
[INFO] [stdout] 123 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2"), h!("text/html;q=0.3")])).to(be_equal_to(vec![h!("text/html;q=0.3"), h!("te...
[INFO] [stdout]     |                                  ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:123:58
[INFO] [stdout]     |
[INFO] [stdout] 123 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2"), h!("text/html;q=0.3")])).to(be_equal_to(vec![h!("text/html;q=0.3"), h!("te...
[INFO] [stdout]     |                                                          --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:123:103
[INFO] [stdout]     |
[INFO] [stdout] 123 | ...text/html;q=0.3")])).to(be_equal_to(vec![h!("text/html;q=0.3"), h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                             --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:123:126
[INFO] [stdout]     |
[INFO] [stdout] 123 | ...be_equal_to(vec![h!("text/html;q=0.3"), h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                            ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:124:34
[INFO] [stdout]     |
[INFO] [stdout] 124 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/plain;q=0...
[INFO] [stdout]     |                                  ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:124:58
[INFO] [stdout]     |
[INFO] [stdout] 124 |   expect!(sort_media_types(&vec![h!("text/plain;q=0.2"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/plain;q=0...
[INFO] [stdout]     |                                                          --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:124:97
[INFO] [stdout]     |
[INFO] [stdout] 124 | ...2"), h!("text/html")])).to(be_equal_to(vec![h!("text/html"), h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                                --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:124:114
[INFO] [stdout]     |
[INFO] [stdout] 124 | ...)).to(be_equal_to(vec![h!("text/html"), h!("text/plain;q=0.2")]));
[INFO] [stdout]     |                                            ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:125:34
[INFO] [stdout]     |
[INFO] [stdout] 125 |   expect!(sort_media_types(&vec![h!("audio/*; q=0.2"), h!("audio/basic")])).to(be_equal_to(vec![h!("audio/basic"), h!("audio/*;q=0....
[INFO] [stdout]     |                                  -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:125:56
[INFO] [stdout]     |
[INFO] [stdout] 125 |   expect!(sort_media_types(&vec![h!("audio/*; q=0.2"), h!("audio/basic")])).to(be_equal_to(vec![h!("audio/basic"), h!("audio/*;q=0....
[INFO] [stdout]     |                                                        ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:125:97
[INFO] [stdout]     |
[INFO] [stdout] 125 | ..., h!("audio/basic")])).to(be_equal_to(vec![h!("audio/basic"), h!("audio/*;q=0.2")]));
[INFO] [stdout]     |                                               ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:125:116
[INFO] [stdout]     |
[INFO] [stdout] 125 | ...)).to(be_equal_to(vec![h!("audio/basic"), h!("audio/*;q=0.2")]));
[INFO] [stdout]     |                                              ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:126:34
[INFO] [stdout]     |
[INFO] [stdout] 126 |   expect!(sort_media_types(&vec![h!("audio/*;q=1"), h!("audio/basic;q=0.5")])).to(be_equal_to(vec![h!("audio/*;q=1"), h!("audio/bas...
[INFO] [stdout]     |                                  ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:126:53
[INFO] [stdout]     |
[INFO] [stdout] 126 |   expect!(sort_media_types(&vec![h!("audio/*;q=1"), h!("audio/basic;q=0.5")])).to(be_equal_to(vec![h!("audio/*;q=1"), h!("audio/bas...
[INFO] [stdout]     |                                                     ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:126:100
[INFO] [stdout]     |
[INFO] [stdout] 126 | ...audio/basic;q=0.5")])).to(be_equal_to(vec![h!("audio/*;q=1"), h!("audio/basic;q=0.5")]));
[INFO] [stdout]     |                                               ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:126:119
[INFO] [stdout]     |
[INFO] [stdout] 126 | ....to(be_equal_to(vec![h!("audio/*;q=1"), h!("audio/basic;q=0.5")]));
[INFO] [stdout]     |                                            ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:127:34
[INFO] [stdout]     |
[INFO] [stdout] 127 |   expect!(sort_media_types(&vec![h!("text/plain; q=0.5"), h!("text/html"), h!("text/x-dvi; q=0.8"), h!("text/x-c")]))
[INFO] [stdout]     |                                  ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:127:59
[INFO] [stdout]     |
[INFO] [stdout] 127 |   expect!(sort_media_types(&vec![h!("text/plain; q=0.5"), h!("text/html"), h!("text/x-dvi; q=0.8"), h!("text/x-c")]))
[INFO] [stdout]     |                                                           --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:127:76
[INFO] [stdout]     |
[INFO] [stdout] 127 |   expect!(sort_media_types(&vec![h!("text/plain; q=0.5"), h!("text/html"), h!("text/x-dvi; q=0.8"), h!("text/x-c")]))
[INFO] [stdout]     |                                                                            ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:127:101
[INFO] [stdout]     |
[INFO] [stdout] 127 |   expect!(sort_media_types(&vec![h!("text/plain; q=0.5"), h!("text/html"), h!("text/x-dvi; q=0.8"), h!("text/x-c")]))
[INFO] [stdout]     |                                                                                                     -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:128:26
[INFO] [stdout]     |
[INFO] [stdout] 128 |     .to(be_equal_to(vec![h!("text/html"), h!("text/x-c"), h!("text/x-dvi;q=0.8"), h!("text/plain;q=0.5")]));
[INFO] [stdout]     |                          --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:128:43
[INFO] [stdout]     |
[INFO] [stdout] 128 |     .to(be_equal_to(vec![h!("text/html"), h!("text/x-c"), h!("text/x-dvi;q=0.8"), h!("text/plain;q=0.5")]));
[INFO] [stdout]     |                                           -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:128:59
[INFO] [stdout]     |
[INFO] [stdout] 128 |     .to(be_equal_to(vec![h!("text/html"), h!("text/x-c"), h!("text/x-dvi;q=0.8"), h!("text/plain;q=0.5")]));
[INFO] [stdout]     |                                                           ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:128:83
[INFO] [stdout]     |
[INFO] [stdout] 128 |     .to(be_equal_to(vec![h!("text/html"), h!("text/x-c"), h!("text/x-dvi;q=0.8"), h!("text/plain;q=0.5")]));
[INFO] [stdout]     |                                                                                   ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |       "Accept-Language".to_string() => vec![h!("en-gb")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:200:45
[INFO] [stdout]     |
[INFO] [stdout] 200 |       "Accept-Language".to_string() => vec![h!("en-gb")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:215:45
[INFO] [stdout]     |
[INFO] [stdout] 215 |       "Accept-Language".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                             ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:230:45
[INFO] [stdout]     |
[INFO] [stdout] 230 |       "Accept-Language".to_string() => vec![h!("en-gb")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:245:45
[INFO] [stdout]     |
[INFO] [stdout] 245 |       "Accept-Language".to_string() => vec![h!("en-gb")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:260:45
[INFO] [stdout]     |
[INFO] [stdout] 260 |       "Accept-Language".to_string() => vec![h!("en-gb;q=0")]
[INFO] [stdout]     |                                             --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:275:45
[INFO] [stdout]     |
[INFO] [stdout] 275 |       "Accept-Language".to_string() => vec![h!("*;q=0")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:302:9
[INFO] [stdout]     |
[INFO] [stdout] 302 |         h!("da"),
[INFO] [stdout]     |         -------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:303:9
[INFO] [stdout]     |
[INFO] [stdout] 303 |         h!("en-gb;q=0.8"),
[INFO] [stdout]     |         ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:304:9
[INFO] [stdout]     |
[INFO] [stdout] 304 |         h!("en;q=0.7")
[INFO] [stdout]     |         -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:342:44
[INFO] [stdout]     |
[INFO] [stdout] 342 |       "Accept-Charset".to_string() => vec![h!("ISO-8859-5")]
[INFO] [stdout]     |                                            ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:372:44
[INFO] [stdout]     |
[INFO] [stdout] 372 |       "Accept-Charset".to_string() => vec![h!("ISO-8859-5")]
[INFO] [stdout]     |                                            ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:387:44
[INFO] [stdout]     |
[INFO] [stdout] 387 |       "Accept-Charset".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                            ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:402:44
[INFO] [stdout]     |
[INFO] [stdout] 402 |       "Accept-Charset".to_string() => vec![h!("US-ASCII;q=0")]
[INFO] [stdout]     |                                            ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:429:9
[INFO] [stdout]     |
[INFO] [stdout] 429 |         h!("ISO-8859-1"),
[INFO] [stdout]     |         ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:430:9
[INFO] [stdout]     |
[INFO] [stdout] 430 |         h!("UTF-8;q=0.8"),
[INFO] [stdout]     |         ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:431:9
[INFO] [stdout]     |
[INFO] [stdout] 431 |         h!("US-ASCII;q=0.7")
[INFO] [stdout]     |         -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:444:37
[INFO] [stdout]     |
[INFO] [stdout] 444 |   expect!(sort_media_charsets(&vec![h!("iso-8859-5")]))
[INFO] [stdout]     |                                     ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:446:37
[INFO] [stdout]     |
[INFO] [stdout] 446 |   expect!(sort_media_charsets(&vec![h!("unicode-1-1;q=0.8"), h!("iso-8859-5")]))
[INFO] [stdout]     |                                     ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:446:62
[INFO] [stdout]     |
[INFO] [stdout] 446 |   expect!(sort_media_charsets(&vec![h!("unicode-1-1;q=0.8"), h!("iso-8859-5")]))
[INFO] [stdout]     |                                                              ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:449:37
[INFO] [stdout]     |
[INFO] [stdout] 449 |   expect!(sort_media_charsets(&vec![h!("US-ASCII;q=0.8"), h!("*;q=0.5")]))
[INFO] [stdout]     |                                     -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:449:59
[INFO] [stdout]     |
[INFO] [stdout] 449 |   expect!(sort_media_charsets(&vec![h!("US-ASCII;q=0.8"), h!("*;q=0.5")]))
[INFO] [stdout]     |                                                           ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:452:37
[INFO] [stdout]     |
[INFO] [stdout] 452 |   expect!(sort_media_charsets(&vec![h!("iso-8859-1; q=0.2"), h!("iso-8859-5")]))
[INFO] [stdout]     |                                     ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:452:62
[INFO] [stdout]     |
[INFO] [stdout] 452 |   expect!(sort_media_charsets(&vec![h!("iso-8859-1; q=0.2"), h!("iso-8859-5")]))
[INFO] [stdout]     |                                                              ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:496:45
[INFO] [stdout]     |
[INFO] [stdout] 496 |       "Accept-Encoding".to_string() => vec![h!("compress"), h!("*;q=0")]
[INFO] [stdout]     |                                             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:496:61
[INFO] [stdout]     |
[INFO] [stdout] 496 |       "Accept-Encoding".to_string() => vec![h!("compress"), h!("*;q=0")]
[INFO] [stdout]     |                                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:541:45
[INFO] [stdout]     |
[INFO] [stdout] 541 |       "Accept-Encoding".to_string() => vec![h!("gzip")]
[INFO] [stdout]     |                                             ---------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:556:45
[INFO] [stdout]     |
[INFO] [stdout] 556 |       "Accept-Encoding".to_string() => vec![h!("*")]
[INFO] [stdout]     |                                             ------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:571:45
[INFO] [stdout]     |
[INFO] [stdout] 571 |       "Accept-Encoding".to_string() => vec![h!("gzip;q=0")]
[INFO] [stdout]     |                                             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:586:45
[INFO] [stdout]     |
[INFO] [stdout] 586 |       "Accept-Encoding".to_string() => vec![h!("*;q=0")]
[INFO] [stdout]     |                                             ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:601:45
[INFO] [stdout]     |
[INFO] [stdout] 601 |       "Accept-Encoding".to_string() => vec![h!("gzip")]
[INFO] [stdout]     |                                             ---------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:628:11
[INFO] [stdout]     |
[INFO] [stdout] 628 |           h!("gzip;q=1.0"),
[INFO] [stdout]     |           ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:629:11
[INFO] [stdout]     |
[INFO] [stdout] 629 |           h!("*;q=0"),
[INFO] [stdout]     |           ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:630:11
[INFO] [stdout]     |
[INFO] [stdout] 630 |           h!("identity; q=0.5")
[INFO] [stdout]     |           --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:643:32
[INFO] [stdout]     |
[INFO] [stdout] 643 |   expect!(sort_encodings(&vec![h!("gzip")]))
[INFO] [stdout]     |                                ---------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:645:32
[INFO] [stdout]     |
[INFO] [stdout] 645 |   expect!(sort_encodings(&vec![h!("gzip;q=0.8"), h!("compress")]))
[INFO] [stdout]     |                                ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:645:50
[INFO] [stdout]     |
[INFO] [stdout] 645 |   expect!(sort_encodings(&vec![h!("gzip;q=0.8"), h!("compress")]))
[INFO] [stdout]     |                                                  -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:649:32
[INFO] [stdout]     |
[INFO] [stdout] 649 |   expect!(sort_encodings(&vec![h!("gzip;q=0.8"), h!("*;q=0.5")]))
[INFO] [stdout]     |                                ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:649:50
[INFO] [stdout]     |
[INFO] [stdout] 649 |   expect!(sort_encodings(&vec![h!("gzip;q=0.8"), h!("*;q=0.5")]))
[INFO] [stdout]     |                                                  ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:652:32
[INFO] [stdout]     |
[INFO] [stdout] 652 |   expect!(sort_encodings(&vec![h!("gzip; q=0.2"), h!("compress;q=0"), h!("*;q=0")]))
[INFO] [stdout]     |                                ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:652:51
[INFO] [stdout]     |
[INFO] [stdout] 652 |   expect!(sort_encodings(&vec![h!("gzip; q=0.2"), h!("compress;q=0"), h!("*;q=0")]))
[INFO] [stdout]     |                                                   ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/headers.rs:245:43
[INFO] [stdout]     |
[INFO] [stdout] 244 | macro_rules! h {
[INFO] [stdout] 245 |   ($e:expr) => (HeaderValue::parse_string($e.into()))
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/content_negotiation_tests.rs:652:71
[INFO] [stdout]     |
[INFO] [stdout] 652 |   expect!(sort_encodings(&vec![h!("gzip; q=0.2"), h!("compress;q=0"), h!("*;q=0")]))
[INFO] [stdout]     |                                                                       ----------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<&str as Into<&str>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `webmachine-rust` (lib test) due to 122 previous errors
[INFO] [stderr] warning: unused dependency `futures`
[INFO] [stderr]   --> Cargo.toml:13:15
[INFO] [stderr]    |
[INFO] [stderr] 13 | [dependencies.futures]
[INFO] [stderr]    |               ^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `futures`
[INFO] [stderr] warning: unused dependency `hyper-util`
[INFO] [stderr]   --> Cargo.toml:35:15
[INFO] [stderr]    |
[INFO] [stderr] 35 | [dependencies.hyper-util]
[INFO] [stderr]    |               ^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the dependency on `hyper-util`
[INFO] [stderr] warning: unused dependency `serde`
[INFO] [stderr]   --> Cargo.toml:48:15
[INFO] [stderr]    |
[INFO] [stderr] 48 | [dependencies.serde]
[INFO] [stderr]    |               ^^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the dependency on `serde`
[INFO] [stderr] warning: unused dependency `serde_json`
[INFO] [stderr]   --> Cargo.toml:51:15
[INFO] [stderr]    |
[INFO] [stderr] 51 | [dependencies.serde_json]
[INFO] [stderr]    |               ^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the dependency on `serde_json`
[INFO] [stderr] warning: `webmachine-rust` (manifest) generated 4 warnings
[INFO] running `Command { std: "docker" "inspect" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1", kill_on_drop: false }`
[INFO] [stdout] e5eca8d13dbc3a9a9242b3838d885c7250da750bfe03f8efbb35720e54719af1
