[INFO] fetching crate numbat 1.24.0...
[INFO] checking numbat-1.24.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate numbat 1.24.0 into /workspace/builds/worker-3-tc2/source
[INFO] started tweaking crates.io crate numbat 1.24.0
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate numbat 1.24.0
[INFO] tweaked toml for crates.io crate numbat 1.24.0 written to /workspace/builds/worker-3-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate numbat 1.24.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate numbat 1.24.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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] 0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef
[INFO] running `Command { std: "docker" "start" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef", 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" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef", 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" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.172
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling cc v1.2.26
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling zerocopy v0.8.25
[INFO] [stderr]    Compiling syn v2.0.101
[INFO] [stderr]     Checking smallvec v1.15.1
[INFO] [stderr]    Compiling mime_guess v2.0.5
[INFO] [stderr]    Compiling minimal-lexical v0.2.1
[INFO] [stderr]     Checking either v1.15.0
[INFO] [stderr]    Compiling option-ext v0.2.0
[INFO] [stderr]    Compiling rustversion v1.0.21
[INFO] [stderr]    Compiling rustls v0.22.4
[INFO] [stderr]    Compiling mime v0.3.17
[INFO] [stderr]     Checking regex-syntax v0.8.5
[INFO] [stderr]    Compiling typeid v1.0.3
[INFO] [stderr]    Compiling sha2 v0.10.9
[INFO] [stderr]     Checking form_urlencoded v1.2.1
[INFO] [stderr]    Compiling nom v7.1.3
[INFO] [stderr]     Checking webpki-roots v1.0.0
[INFO] [stderr]    Compiling rustc-hash v2.1.1
[INFO] [stderr]    Compiling ryu_floating_decimal v0.1.0
[INFO] [stderr]     Checking webpki-roots v0.26.11
[INFO] [stderr]     Checking humansize v2.1.3
[INFO] [stderr]    Compiling rust-embed-utils v8.7.2
[INFO] [stderr]     Checking half v2.6.0
[INFO] [stderr]     Checking plotters-backend v0.3.7
[INFO] [stderr]     Checking clap_builder v4.5.39
[INFO] [stderr]     Checking castaway v0.2.3
[INFO] [stderr]     Checking plotters-svg v0.3.7
[INFO] [stderr]     Checking itertools v0.10.5
[INFO] [stderr]     Checking bstr v1.12.0
[INFO] [stderr]     Checking quick-xml v0.37.5
[INFO] [stderr]     Checking getrandom v0.2.16
[INFO] [stderr]     Checking getrandom v0.3.3
[INFO] [stderr]     Checking rand_core v0.9.3
[INFO] [stderr]     Checking rand_core v0.6.4
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking hashbrown v0.15.4
[INFO] [stderr]    Compiling dirs-sys v0.5.0
[INFO] [stderr]    Compiling numbat v1.24.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking cast v0.3.0
[INFO] [stderr]     Checking dyn-clone v1.0.19
[INFO] [stderr]    Compiling dirs v6.0.0
[INFO] [stderr]     Checking codespan-reporting v0.12.0
[INFO] [stderr]    Compiling shellexpand v3.1.1
[INFO] [stderr]     Checking num-format v0.4.4
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]     Checking console v0.15.11
[INFO] [stderr]    Compiling ring v0.17.14
[INFO] [stderr]     Checking is-terminal v0.4.16
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]     Checking pretty_dtoa v0.3.0
[INFO] [stderr]     Checking rayon v1.10.0
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]     Checking oorandom v11.1.5
[INFO] [stderr]     Checking criterion-plot v0.5.0
[INFO] [stderr]     Checking strfmt v0.2.4
[INFO] [stderr]     Checking indexmap v2.9.0
[INFO] [stderr]     Checking mendeleev v0.8.4
[INFO] [stderr]     Checking anes v0.1.6
[INFO] [stderr]     Checking jiff v0.2.18
[INFO] [stderr]     Checking unicode-ident v1.0.18
[INFO] [stderr]     Checking similar v2.7.0
[INFO] [stderr]     Checking approx v0.5.1
[INFO] [stderr]     Checking glob v0.3.2
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]     Checking regex-automata v0.4.9
[INFO] [stderr]     Checking rand_chacha v0.3.1
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]     Checking num-rational v0.4.2
[INFO] [stderr]     Checking rand v0.8.5
[INFO] [stderr]     Checking rand v0.9.1
[INFO] [stderr]    Compiling synstructure v0.13.2
[INFO] [stderr]    Compiling darling_core v0.20.11
[INFO] [stderr]     Checking regex v1.11.1
[INFO] [stderr]     Checking globset v0.4.18
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling zerovec-derive v0.11.1
[INFO] [stderr]    Compiling displaydoc v0.2.5
[INFO] [stderr]    Compiling clap_derive v4.5.32
[INFO] [stderr]    Compiling serde_repr v0.1.20
[INFO] [stderr]    Compiling thiserror-impl v2.0.12
[INFO] [stderr]    Compiling rust-embed-impl v8.7.2
[INFO] [stderr]    Compiling zerofrom-derive v0.1.6
[INFO] [stderr]    Compiling yoke-derive v0.8.0
[INFO] [stderr]     Checking insta v1.43.1
[INFO] [stderr]     Checking rust-embed v8.7.2
[INFO] [stderr]     Checking rustls-webpki v0.102.8
[INFO] [stderr]     Checking zerofrom v0.1.6
[INFO] [stderr]     Checking yoke v0.8.0
[INFO] [stderr]     Checking thiserror v2.0.12
[INFO] [stderr]     Checking zerovec v0.11.2
[INFO] [stderr]     Checking zerotrie v0.2.2
[INFO] [stderr]    Compiling darling_macro v0.20.11
[INFO] [stderr]     Checking clap v4.5.39
[INFO] [stderr]    Compiling darling v0.20.11
[INFO] [stderr]    Compiling serde_with_macros v3.12.0
[INFO] [stderr]    Compiling plotly_derive v0.12.1
[INFO] [stderr]     Checking tinystr v0.8.1
[INFO] [stderr]     Checking potential_utf v0.1.2
[INFO] [stderr]     Checking icu_collections v2.0.0
[INFO] [stderr]     Checking icu_locale_core v2.0.0
[INFO] [stderr]     Checking icu_provider v2.0.0
[INFO] [stderr]     Checking icu_properties v2.0.1
[INFO] [stderr]     Checking icu_normalizer v2.0.0
[INFO] [stderr]    Compiling rinja_parser v0.3.5
[INFO] [stderr]    Compiling basic-toml v0.1.10
[INFO] [stderr]     Checking serde_json v1.0.140
[INFO] [stderr]     Checking erased-serde v0.4.6
[INFO] [stderr]     Checking serde_with v3.12.0
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking compact_str v0.9.0
[INFO] [stderr]     Checking idna_adapter v1.2.1
[INFO] [stderr]     Checking idna v1.0.3
[INFO] [stderr]     Checking url v2.5.4
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking criterion v0.5.1
[INFO] [stderr]     Checking attohttpc v0.27.0
[INFO] [stderr]     Checking numbat-exchange-rates v0.6.0
[INFO] [stderr]    Compiling rinja_derive v0.3.5
[INFO] [stderr]     Checking rinja v0.3.5
[INFO] [stderr]     Checking plotly v0.12.1
[INFO] [stdout] error: useless conversion to the same type: `NumbatList<Value>`
[INFO] [stdout]   --> src/ffi/macros.rs:68:24
[INFO] [stdout]    |
[INFO] [stdout] 66 | macro_rules! return_list {
[INFO] [stdout] 67 |     ($value:expr) => {
[INFO] [stdout] 68 |         Ok(Value::List($value.into()))
[INFO] [stdout]    |                        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/ffi/lists.rs:52:5
[INFO] [stdout]    |
[INFO] [stdout] 52 |     return_list!(list)
[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 `<NumbatList<Value> as Into<NumbatList<Value>>::into(val) to avoid triggering this lint
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NumbatList<Value>`
[INFO] [stdout]   --> src/ffi/macros.rs:68:24
[INFO] [stdout]    |
[INFO] [stdout] 66 | macro_rules! return_list {
[INFO] [stdout] 67 |     ($value:expr) => {
[INFO] [stdout] 68 |         Ok(Value::List($value.into()))
[INFO] [stdout]    |                        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/ffi/lists.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |     return_list!(list)
[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 `<NumbatList<Value> as Into<NumbatList<Value>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `numbat` (lib) due to 2 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `list::NumbatList<Value>`
[INFO] [stdout]   --> src/ffi/macros.rs:68:24
[INFO] [stdout]    |
[INFO] [stdout] 66 | macro_rules! return_list {
[INFO] [stdout] 67 |     ($value:expr) => {
[INFO] [stdout] 68 |         Ok(Value::List($value.into()))
[INFO] [stdout]    |                        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/ffi/lists.rs:52:5
[INFO] [stdout]    |
[INFO] [stdout] 52 |     return_list!(list)
[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 `<list::NumbatList<Value> as Into<list::NumbatList<Value>>::into(val) to avoid triggering this lint
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `list::NumbatList<Value>`
[INFO] [stdout]   --> src/ffi/macros.rs:68:24
[INFO] [stdout]    |
[INFO] [stdout] 66 | macro_rules! return_list {
[INFO] [stdout] 67 |     ($value:expr) => {
[INFO] [stdout] 68 |         Ok(Value::List($value.into()))
[INFO] [stdout]    |                        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/ffi/lists.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |     return_list!(list)
[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 `<list::NumbatList<Value> as Into<list::NumbatList<Value>>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2303:47
[INFO] [stdout]      |
[INFO] [stdout] 2303 |         parse_as_expression(&["_50_000_000"], identifier!("_50_000_000"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2342:54
[INFO] [stdout]      |
[INFO] [stdout] 2342 |         parse_as_expression(&["-x", " - x"], negate!(identifier!("x")));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2353:46
[INFO] [stdout]      |
[INFO] [stdout] 2353 |         parse_as_expression(&["+x", " + x"], identifier!("x"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2383:72
[INFO] [stdout]      |
[INFO] [stdout] 2383 |         parse_as_expression(&["1e", "1.0e"], binop!(scalar!(1.0), Mul, identifier!("e")));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2384:65
[INFO] [stdout]      |
[INFO] [stdout] 2384 |         parse_as_expression(&["1ee"], binop!(scalar!(1.0), Mul, identifier!("ee")));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2385:65
[INFO] [stdout]      |
[INFO] [stdout] 2385 |         parse_as_expression(&["1eV"], binop!(scalar!(1.0), Mul, identifier!("eV")));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2386:66
[INFO] [stdout]      |
[INFO] [stdout] 2386 |         parse_as_expression(&["1erg"], binop!(scalar!(1.0), Mul, identifier!("erg")));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2421:51
[INFO] [stdout]      |
[INFO] [stdout] 2421 |         parse_as_expression(&["foo", "  foo   "], identifier!("foo"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2422:43
[INFO] [stdout]      |
[INFO] [stdout] 2422 |         parse_as_expression(&["foo_bar"], identifier!("foo_bar"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2423:55
[INFO] [stdout]      |
[INFO] [stdout] 2423 |         parse_as_expression(&["MeineSchöneVariable"], identifier!("MeineSchöneVariable"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2424:37
[INFO] [stdout]      |
[INFO] [stdout] 2424 |         parse_as_expression(&["°"], identifier!("°"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2425:37
[INFO] [stdout]      |
[INFO] [stdout] 2425 |         parse_as_expression(&["′"], identifier!("′"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2426:37
[INFO] [stdout]      |
[INFO] [stdout] 2426 |         parse_as_expression(&["″"], identifier!("″"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2427:44
[INFO] [stdout]      |
[INFO] [stdout] 2427 |         parse_as_expression(&["Mass_H₂O"], identifier!("Mass_H₂O"));
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2471:24
[INFO] [stdout]      |
[INFO] [stdout] 2471 |                 binop!(identifier!("meter"), Div, identifier!("second"))
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2471:51
[INFO] [stdout]      |
[INFO] [stdout] 2471 |                 binop!(identifier!("meter"), Div, identifier!("second"))
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2500:39
[INFO] [stdout]      |
[INFO] [stdout] 2500 |             binop!(scalar!(2.0), Mul, identifier!("meter")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2622:49
[INFO] [stdout]      |
[INFO] [stdout] 2622 |                 expr: binop!(scalar!(1.0), Mul, identifier!("meter")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2657:49
[INFO] [stdout]      |
[INFO] [stdout] 2657 |                 expr: binop!(scalar!(1.0), Mul, identifier!("meter")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3101:28
[INFO] [stdout]      |
[INFO] [stdout] 3101 |                 body: Some(identifier!("y")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3105:34
[INFO] [stdout]      |
[INFO] [stdout] 3105 |                     expr: binop!(identifier!("x"), Mul, scalar!(2.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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3124:35
[INFO] [stdout]      |
[INFO] [stdout] 3124 |                 body: Some(binop!(identifier!("z"), Add, identifier!("y"))),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3124:58
[INFO] [stdout]      |
[INFO] [stdout] 3124 |                 body: Some(binop!(identifier!("z"), Add, identifier!("y"))),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3129:38
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                         expr: binop!(identifier!("x"), Add, identifier!("x")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3129:61
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                         expr: binop!(identifier!("x"), Add, identifier!("x")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3136:38
[INFO] [stdout]      |
[INFO] [stdout] 3136 |                         expr: binop!(identifier!("y"), Add, identifier!("x")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3136:61
[INFO] [stdout]      |
[INFO] [stdout] 3136 |                         expr: binop!(identifier!("y"), Add, identifier!("x")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3169:36
[INFO] [stdout]      |
[INFO] [stdout] 3169 |                 callable: Box::new(identifier!("foo")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3179:36
[INFO] [stdout]      |
[INFO] [stdout] 3179 |                 callable: Box::new(identifier!("foo")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3189:36
[INFO] [stdout]      |
[INFO] [stdout] 3189 |                 callable: Box::new(identifier!("foo")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3230:40
[INFO] [stdout]      |
[INFO] [stdout] 3230 |                     callable: Box::new(identifier!("returns_fn")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3245:40
[INFO] [stdout]      |
[INFO] [stdout] 3245 |                     callable: Box::new(identifier!("returns_fn")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3260:36
[INFO] [stdout]      |
[INFO] [stdout] 3260 |                 callable: Box::new(identifier!("foo")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3269:36
[INFO] [stdout]      |
[INFO] [stdout] 3269 |                 callable: Box::new(identifier!("kefir")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3502:40
[INFO] [stdout]      |
[INFO] [stdout] 3502 |                         expr: Box::new(identifier!("pi")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3515:36
[INFO] [stdout]      |
[INFO] [stdout] 3515 |                     expr: Box::new(identifier!("pi")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3528:40
[INFO] [stdout]      |
[INFO] [stdout] 3528 |                         expr: Box::new(identifier!("pi")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3533:40
[INFO] [stdout]      |
[INFO] [stdout] 3533 |                         expr: Box::new(identifier!("e")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3547:40
[INFO] [stdout]      |
[INFO] [stdout] 3547 |                         expr: Box::new(identifier!("pi")),
[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/ast.rs:182:76
[INFO] [stdout]      |
[INFO] [stdout]  181 | macro_rules! identifier {
[INFO] [stdout]  182 |     ( $name:expr ) => {{ crate::ast::Expression::Identifier(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3553:40
[INFO] [stdout]      |
[INFO] [stdout] 3553 |                         expr: Box::new(identifier!("e")),
[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: `bool`
[INFO] [stdout]     --> src/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3360:24
[INFO] [stdout]      |
[INFO] [stdout] 3360 |                 binop!(boolean!(true), LogicalOr, binop!(boolean!(false), LogicalAnd, boolean!(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/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3360:58
[INFO] [stdout]      |
[INFO] [stdout] 3360 |                 binop!(boolean!(true), LogicalOr, binop!(boolean!(false), LogicalAnd, boolean!(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/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3360:87
[INFO] [stdout]      |
[INFO] [stdout] 3360 |                 binop!(boolean!(true), LogicalOr, binop!(boolean!(false), LogicalAnd, boolean!(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/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3362:17
[INFO] [stdout]      |
[INFO] [stdout] 3362 |                 boolean!(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/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3370:30
[INFO] [stdout]      |
[INFO] [stdout] 3370 |                 logical_neg!(boolean!(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/ast.rs:187:73
[INFO] [stdout]      |
[INFO] [stdout]  186 | macro_rules! boolean {
[INFO] [stdout]  187 |     ( $name:expr ) => {{ crate::ast::Expression::Boolean(Span::dummy(), $name.into()) }};
[INFO] [stdout]      |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3372:17
[INFO] [stdout]      |
[INFO] [stdout] 3372 |                 boolean!(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 `numbat` (lib test) due to 48 previous errors
[INFO] running `Command { std: "docker" "inspect" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef", kill_on_drop: false }`
[INFO] [stdout] 0393f56921f6a93c136c9103acbc213ae20b9223261918b8c07e8cd38d4dd0ef
