[INFO] cloning repository https://github.com/tinyblinker/lisp_rs
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/tinyblinker/lisp_rs" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ftinyblinker%2Flisp_rs", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ftinyblinker%2Flisp_rs'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] b88863110e61ed0a0a83ed09cb02005a32abe5c5
[INFO] checking tinyblinker/lisp_rs against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ftinyblinker%2Flisp_rs" "/workspace/builds/worker-4-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-4-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/tinyblinker/lisp_rs
[INFO] finished tweaking git repo https://github.com/tinyblinker/lisp_rs
[INFO] tweaked toml for git repo https://github.com/tinyblinker/lisp_rs written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/tinyblinker/lisp_rs 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 git repo https://github.com/tinyblinker/lisp_rs 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] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-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] c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e
[INFO] running `Command { std: "docker" "start" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e", 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" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e", 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" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking my_lisp v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/parser.rs:111:28
[INFO] [stdout]     |
[INFO] [stdout] 111 |         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 111 -         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout] 111 +         if is_valid_string(token).is_ok() {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 111 -         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout] 111 +         if is_valid_string(<&str as Into<_>>::into(token)).is_ok() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:487:16
[INFO] [stdout]     |
[INFO] [stdout] 487 |             Ok(number!(sum))
[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:505:20
[INFO] [stdout]     |
[INFO] [stdout] 505 |                 Ok(number!(-nums[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:507:20
[INFO] [stdout]     |
[INFO] [stdout] 507 |                 Ok(number!(nums[0] - nums[1..].iter().sum::<f64>()))
[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:519:16
[INFO] [stdout]     |
[INFO] [stdout] 519 |             Ok(number!(result))
[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:537:20
[INFO] [stdout]     |
[INFO] [stdout] 537 |                 Ok(number!(1f64 / nums[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:544:20
[INFO] [stdout]     |
[INFO] [stdout] 544 |                 Ok(number!(result))
[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/lib.rs:128:25
[INFO] [stdout]     |
[INFO] [stdout] 126 | macro_rules! number {
[INFO] [stdout] 127 |     ($name:expr) => {
[INFO] [stdout] 128 |         LispExp::Number($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:553:20
[INFO] [stdout]     |
[INFO] [stdout] 553 |                 Ok(number!(num * num))
[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 `<f64 as Into<f64>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `my_lisp` (lib) due to 8 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/parser.rs:111:28
[INFO] [stdout]     |
[INFO] [stdout] 111 |         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 111 -         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout] 111 +         if is_valid_string(token).is_ok() {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 111 -         if is_valid_string(token.into()).is_ok() {
[INFO] [stdout] 111 +         if is_valid_string(<&str as Into<_>>::into(token)).is_ok() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:261:13
[INFO] [stdout]     |
[INFO] [stdout] 261 |             "(".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -             "(".into(),
[INFO] [stdout] 261 +             "(",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -             "(".into(),
[INFO] [stdout] 261 +             <&str as Into<_>>::into("("),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:262:13
[INFO] [stdout]     |
[INFO] [stdout] 262 |             "+".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -             "+".into(),
[INFO] [stdout] 262 +             "+",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -             "+".into(),
[INFO] [stdout] 262 +             <&str as Into<_>>::into("+"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:263:13
[INFO] [stdout]     |
[INFO] [stdout] 263 |             "1".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 263 -             "1".into(),
[INFO] [stdout] 263 +             "1",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 -             "1".into(),
[INFO] [stdout] 263 +             <&str as Into<_>>::into("1"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:264:13
[INFO] [stdout]     |
[INFO] [stdout] 264 |             "(".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "(".into(),
[INFO] [stdout] 264 +             "(",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "(".into(),
[INFO] [stdout] 264 +             <&str as Into<_>>::into("("),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:265:13
[INFO] [stdout]     |
[INFO] [stdout] 265 |             "*".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 265 -             "*".into(),
[INFO] [stdout] 265 +             "*",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 -             "*".into(),
[INFO] [stdout] 265 +             <&str as Into<_>>::into("*"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:266:13
[INFO] [stdout]     |
[INFO] [stdout] 266 |             "2".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 266 -             "2".into(),
[INFO] [stdout] 266 +             "2",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 -             "2".into(),
[INFO] [stdout] 266 +             <&str as Into<_>>::into("2"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:267:13
[INFO] [stdout]     |
[INFO] [stdout] 267 |             "3".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -             "3".into(),
[INFO] [stdout] 267 +             "3",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -             "3".into(),
[INFO] [stdout] 267 +             <&str as Into<_>>::into("3"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:268:13
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ")".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 268 -             ")".into(),
[INFO] [stdout] 268 +             ")",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 -             ")".into(),
[INFO] [stdout] 268 +             <&str as Into<_>>::into(")"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:269:13
[INFO] [stdout]     |
[INFO] [stdout] 269 |             ")".into(),
[INFO] [stdout]     |             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -             ")".into(),
[INFO] [stdout] 269 +             ")",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 -             ")".into(),
[INFO] [stdout] 269 +             <&str as Into<_>>::into(")"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:285:21
[INFO] [stdout]     |
[INFO] [stdout] 285 |             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout]     |                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&["(", "+".into(), "1".into()]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&[<&str as Into<_>>::into("("), "+".into(), "1".into()]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:285:33
[INFO] [stdout]     |
[INFO] [stdout] 285 |             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout]     |                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&["(".into(), "+", "1".into()]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&["(".into(), <&str as Into<_>>::into("+"), "1".into()]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:285:45
[INFO] [stdout]     |
[INFO] [stdout] 285 |             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout]     |                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&["(".into(), "+".into(), "1"]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -             parse(&["(".into(), "+".into(), "1".into()]),
[INFO] [stdout] 285 +             parse(&["(".into(), "+".into(), <&str as Into<_>>::into("1")]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/lib.rs:293:21
[INFO] [stdout]     |
[INFO] [stdout] 293 |             parse(&[")".into()]),
[INFO] [stdout]     |                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 293 -             parse(&[")".into()]),
[INFO] [stdout] 293 +             parse(&[")"]),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 293 -             parse(&[")".into()]),
[INFO] [stdout] 293 +             parse(&[<&str as Into<_>>::into(")")]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 277 |                 list!(vec![symbol!(intern("*")), number!(2f64), number!(3f64)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 |   macro_rules! list {
[INFO] [stdout] 135 |       ($name:expr) => {
[INFO] [stdout] 136 |           LispExp::List($name.into())
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 274 | /             list!(vec![
[INFO] [stdout] 275 | |                 symbol!(intern("+")),
[INFO] [stdout] 276 | |                 number!(1f64),
[INFO] [stdout] 277 | |                 list!(vec![symbol!(intern("*")), number!(2f64), number!(3f64)])
[INFO] [stdout] 278 | |             ])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 796 |             list!(vec![number!(1), number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 805 |             list!(vec![number!(0), number!(1), number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 835 |             list!(vec![number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 906 |             list!(vec![number!(1), number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 910 |             list!(vec![number!(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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 930 |             list!(vec![number!(3), number!(2), number!(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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 940 |             list!(vec![number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 961 |             list!(vec![number!(2), number!(3), number!(4)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]    --> src/lib.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 134 | macro_rules! list {
[INFO] [stdout] 135 |     ($name:expr) => {
[INFO] [stdout] 136 |         LispExp::List($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 966 |             list!(vec![number!(2), number!(4), number!(6)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]     --> src/lib.rs:136:23
[INFO] [stdout]      |
[INFO] [stdout]  134 | macro_rules! list {
[INFO] [stdout]  135 |     ($name:expr) => {
[INFO] [stdout]  136 |         LispExp::List($name.into())
[INFO] [stdout]      |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1062 |             list!(vec![number!(2), number!(4)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]     --> src/lib.rs:136:23
[INFO] [stdout]      |
[INFO] [stdout]  134 | macro_rules! list {
[INFO] [stdout]  135 |     ($name:expr) => {
[INFO] [stdout]  136 |         LispExp::List($name.into())
[INFO] [stdout]      |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1066 |             list!(vec![])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]     --> src/lib.rs:136:23
[INFO] [stdout]      |
[INFO] [stdout]  134 | macro_rules! list {
[INFO] [stdout]  135 |     ($name:expr) => {
[INFO] [stdout]  136 |         LispExp::List($name.into())
[INFO] [stdout]      |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1076 |             list!(vec![number!(1), number!(2), number!(3)])
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]     --> src/lib.rs:136:23
[INFO] [stdout]      |
[INFO] [stdout]  134 | macro_rules! list {
[INFO] [stdout]  135 |     ($name:expr) => {
[INFO] [stdout]  136 |         LispExp::List($name.into())
[INFO] [stdout]      |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1161 |             list!(vec!(symbol!(intern("a")), number!(2), symbol!(intern("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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<LispExp>`
[INFO] [stdout]     --> src/lib.rs:136:23
[INFO] [stdout]      |
[INFO] [stdout]  134 |   macro_rules! list {
[INFO] [stdout]  135 |       ($name:expr) => {
[INFO] [stdout]  136 |           LispExp::List($name.into())
[INFO] [stdout]      |                         ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1170 | /             list!(vec!(
[INFO] [stdout] 1171 | |                 symbol!(intern("a")),
[INFO] [stdout] 1172 | |                 number!(1),
[INFO] [stdout] 1173 | |                 number!(2),
[INFO] [stdout] 1174 | |                 symbol!(intern("c"))
[INFO] [stdout] 1175 | |             )),
[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 `<Vec<LispExp> as Into<Vec<LispExp>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 429 |         assert_eq!(eval_str("#t", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 430 |         assert_eq!(eval_str("#f", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 438 |         assert_eq!(eval_str("(= 1 1)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 439 |         assert_eq!(eval_str("(= 1 2)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 441 |         assert_eq!(eval_str("(> 1 3)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 442 |         assert_eq!(eval_str("(> 3 1)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 444 |         assert_eq!(eval_str("(>= 1 3)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 445 |         assert_eq!(eval_str("(>= 3 3)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 446 |         assert_eq!(eval_str("(>= 3 1)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 448 |         assert_eq!(eval_str("(< 1 3)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 449 |         assert_eq!(eval_str("(< 3 1)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 451 |         assert_eq!(eval_str("(<= 1 3)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 452 |         assert_eq!(eval_str("(<= 3 3)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 453 |         assert_eq!(eval_str("(<= 3 1)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 722 |         assert_eq!(eval_str("(and #t #f)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 724 |         assert_eq!(eval_str("(and )", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 731 |         assert_eq!(eval_str("(or #f #f #t)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 732 |         assert_eq!(eval_str("(or )", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 761 |             bool!(true)
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 785 |         assert_eq!(eval_str("(not #t)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 786 |         assert_eq!(eval_str("(not #f)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 787 |         assert_eq!(eval_str("(not nil)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 788 |         assert_eq!(eval_str("(not 0)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 944 |             bool!(false)
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 952 |         assert_eq!(eval_str("(null? nil)", &mut env).unwrap(), bool!(true));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:144:23
[INFO] [stdout]     |
[INFO] [stdout] 142 | macro_rules! bool {
[INFO] [stdout] 143 |     ($name:expr) => {
[INFO] [stdout] 144 |         LispExp::Bool($name.into())
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 953 |         assert_eq!(eval_str("(null? 0)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:144:23
[INFO] [stdout]      |
[INFO] [stdout]  142 | macro_rules! bool {
[INFO] [stdout]  143 |     ($name:expr) => {
[INFO] [stdout]  144 |         LispExp::Bool($name.into())
[INFO] [stdout]      |                       ^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1124 |         assert_eq!(eval_str("(my-or #f tmp)", &mut env).unwrap(), bool!(false));
[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 `<bool as Into<bool>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `my_lisp` (lib test) due to 57 previous errors
[INFO] running `Command { std: "docker" "inspect" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e", kill_on_drop: false }`
[INFO] [stdout] c1eba9671239740bb2702ceb96e4a416330deb68075cf2de59a0c075a08b976e
