[INFO] cloning repository https://github.com/gavincrawford/lily
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/gavincrawford/lily" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgavincrawford%2Flily", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgavincrawford%2Flily'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 3ec6856a1980c969cb5ecbedfe49816d3e627d79
[INFO] checking gavincrawford/lily against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgavincrawford%2Flily" "/workspace/builds/worker-5-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-5-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/gavincrawford/lily
[INFO] finished tweaking git repo https://github.com/gavincrawford/lily
[INFO] tweaked toml for git repo https://github.com/gavincrawford/lily written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/gavincrawford/lily 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] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 93 packages to highest compatible versions
[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-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd
[INFO] running `Command { std: "docker" "start" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd", 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" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd", 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" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling unicode-ident v1.0.27
[INFO] [stderr]    Compiling find-msvc-tools v0.1.15
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.21
[INFO] [stderr]    Compiling zerocopy v0.8.63
[INFO] [stderr]    Compiling crossbeam-deque v0.8.8
[INFO] [stderr]    Compiling libc v0.2.191
[INFO] [stderr]     Checking either v1.19.0
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling serde_json v1.0.154
[INFO] [stderr]     Checking memchr v2.8.3
[INFO] [stderr]     Checking regex-syntax v0.8.11
[INFO] [stderr]     Checking ciborium-io v0.2.2
[INFO] [stderr]    Compiling cc v1.10.0
[INFO] [stderr]     Checking plotters-backend v0.3.7
[INFO] [stderr]     Checking itertools v0.13.0
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking plotters-svg v0.3.7
[INFO] [stderr]     Checking rayon-core v1.13.0
[INFO] [stderr]     Checking cast v0.3.0
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking criterion-plot v0.8.2
[INFO] [stderr]     Checking page_size v0.6.0
[INFO] [stderr]     Checking anes v0.1.6
[INFO] [stderr]    Compiling libmimalloc-sys v0.1.49
[INFO] [stderr]    Compiling alloca v0.4.0
[INFO] [stderr]     Checking oorandom v11.1.5
[INFO] [stderr]     Checking regex v1.13.1
[INFO] [stderr]    Compiling derivative v2.2.0
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]    Compiling clap_derive v4.6.7
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]     Checking mimalloc v0.1.52
[INFO] [stderr]    Compiling zerocopy-derive v0.8.63
[INFO] [stderr]     Checking thiserror v2.0.21
[INFO] [stderr]     Checking lylib v0.32.2 (/opt/rustwide/workdir/lylib)
[INFO] [stderr]     Checking clap v4.6.7
[INFO] [stderr]     Checking ly v0.2.19 (/opt/rustwide/workdir/ly)
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking criterion v0.8.2
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:7:1
[INFO] [stdout]    |
[INFO] [stdout]  7 | / test!(chars => (
[INFO] [stdout]  8 | |     letters == node!([
[INFO] [stdout]  9 | |         lit!('a'),
[INFO] [stdout] 10 | |         lit!('b'),
[INFO] [stdout] ...  |
[INFO] [stdout] 15 | |     ])
[INFO] [stdout] 16 | | ));
[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 `<variable::Variable as Into<variable::Variable>::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: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:18:1
[INFO] [stdout]    |
[INFO] [stdout] 18 | / test!(len => (
[INFO] [stdout] 19 | |     empty_list := 0,
[INFO] [stdout] 20 | |     empty_string := 0,
[INFO] [stdout] 21 | |     string := 11,
[INFO] [stdout] 22 | |     list := 5,
[INFO] [stdout] 23 | |     unicode := 4
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:18:1
[INFO] [stdout]    |
[INFO] [stdout] 18 | / test!(len => (
[INFO] [stdout] 19 | |     empty_list := 0,
[INFO] [stdout] 20 | |     empty_string := 0,
[INFO] [stdout] 21 | |     string := 11,
[INFO] [stdout] 22 | |     list := 5,
[INFO] [stdout] 23 | |     unicode := 4
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:18:1
[INFO] [stdout]    |
[INFO] [stdout] 18 | / test!(len => (
[INFO] [stdout] 19 | |     empty_list := 0,
[INFO] [stdout] 20 | |     empty_string := 0,
[INFO] [stdout] 21 | |     string := 11,
[INFO] [stdout] 22 | |     list := 5,
[INFO] [stdout] 23 | |     unicode := 4
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:18:1
[INFO] [stdout]    |
[INFO] [stdout] 18 | / test!(len => (
[INFO] [stdout] 19 | |     empty_list := 0,
[INFO] [stdout] 20 | |     empty_string := 0,
[INFO] [stdout] 21 | |     string := 11,
[INFO] [stdout] 22 | |     list := 5,
[INFO] [stdout] 23 | |     unicode := 4
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:18:1
[INFO] [stdout]    |
[INFO] [stdout] 18 | / test!(len => (
[INFO] [stdout] 19 | |     empty_list := 0,
[INFO] [stdout] 20 | |     empty_string := 0,
[INFO] [stdout] 21 | |     string := 11,
[INFO] [stdout] 22 | |     list := 5,
[INFO] [stdout] 23 | |     unicode := 4
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:28:1
[INFO] [stdout]    |
[INFO] [stdout] 28 | / test!(sort => (
[INFO] [stdout] 29 | |     sorted_numbers == node!([lit!(1), lit!(2), lit!(3), lit!(4), lit!(5)]),
[INFO] [stdout] 30 | |     sorted_words == node!([lit!("apple"), lit!("banana"), lit!("mango")]),
[INFO] [stdout] 31 | |     empty == node!([]),
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     negatives == node!([lit!(-3), lit!(-2), lit!(-1), lit!(0), lit!(1)])
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:40:1
[INFO] [stdout]    |
[INFO] [stdout] 40 | / test!(split => (
[INFO] [stdout] 41 | |     by_comma == node!([lit!("a"), lit!("b"), lit!("c")]),
[INFO] [stdout] 42 | |     by_space == node!([lit!("hello"), lit!("world"), lit!("foo")]),
[INFO] [stdout] 43 | |     no_match == node!([lit!("abc")]),
[INFO] [stdout] 44 | |     by_double_colon == node!([lit!("one"), lit!("two"), lit!("three")]),
[INFO] [stdout] 45 | |     by_nothing == node!([lit!("stuff")])
[INFO] [stdout] 46 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:40:1
[INFO] [stdout]    |
[INFO] [stdout] 40 | / test!(split => (
[INFO] [stdout] 41 | |     by_comma == node!([lit!("a"), lit!("b"), lit!("c")]),
[INFO] [stdout] 42 | |     by_space == node!([lit!("hello"), lit!("world"), lit!("foo")]),
[INFO] [stdout] 43 | |     no_match == node!([lit!("abc")]),
[INFO] [stdout] 44 | |     by_double_colon == node!([lit!("one"), lit!("two"), lit!("three")]),
[INFO] [stdout] 45 | |     by_nothing == node!([lit!("stuff")])
[INFO] [stdout] 46 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:40:1
[INFO] [stdout]    |
[INFO] [stdout] 40 | / test!(split => (
[INFO] [stdout] 41 | |     by_comma == node!([lit!("a"), lit!("b"), lit!("c")]),
[INFO] [stdout] 42 | |     by_space == node!([lit!("hello"), lit!("world"), lit!("foo")]),
[INFO] [stdout] 43 | |     no_match == node!([lit!("abc")]),
[INFO] [stdout] 44 | |     by_double_colon == node!([lit!("one"), lit!("two"), lit!("three")]),
[INFO] [stdout] 45 | |     by_nothing == node!([lit!("stuff")])
[INFO] [stdout] 46 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:40:1
[INFO] [stdout]    |
[INFO] [stdout] 40 | / test!(split => (
[INFO] [stdout] 41 | |     by_comma == node!([lit!("a"), lit!("b"), lit!("c")]),
[INFO] [stdout] 42 | |     by_space == node!([lit!("hello"), lit!("world"), lit!("foo")]),
[INFO] [stdout] 43 | |     no_match == node!([lit!("abc")]),
[INFO] [stdout] 44 | |     by_double_colon == node!([lit!("one"), lit!("two"), lit!("three")]),
[INFO] [stdout] 45 | |     by_nothing == node!([lit!("stuff")])
[INFO] [stdout] 46 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:40:1
[INFO] [stdout]    |
[INFO] [stdout] 40 | / test!(split => (
[INFO] [stdout] 41 | |     by_comma == node!([lit!("a"), lit!("b"), lit!("c")]),
[INFO] [stdout] 42 | |     by_space == node!([lit!("hello"), lit!("world"), lit!("foo")]),
[INFO] [stdout] 43 | |     no_match == node!([lit!("abc")]),
[INFO] [stdout] 44 | |     by_double_colon == node!([lit!("one"), lit!("two"), lit!("three")]),
[INFO] [stdout] 45 | |     by_nothing == node!([lit!("stuff")])
[INFO] [stdout] 46 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:50:1
[INFO] [stdout]    |
[INFO] [stdout] 50 |   test!(sin => (zero := 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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/builtins/mod.rs:53:1
[INFO] [stdout]    |
[INFO] [stdout] 53 |   test!(cos => (zero := 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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(global_variables => (
[INFO] [stdout]  4 | |     a := 1,
[INFO] [stdout]  5 | |     b := true,
[INFO] [stdout]  6 | |     c := "str",
[INFO] [stdout]  7 | |     d := 'c'
[INFO] [stdout]  8 | | ));
[INFO] [stdout]    | |__- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(global_variables => (
[INFO] [stdout]  4 | |     a := 1,
[INFO] [stdout]  5 | |     b := true,
[INFO] [stdout]  6 | |     c := "str",
[INFO] [stdout]  7 | |     d := 'c'
[INFO] [stdout]  8 | | ));
[INFO] [stdout]    | |__- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(global_variables => (
[INFO] [stdout]  4 | |     a := 1,
[INFO] [stdout]  5 | |     b := true,
[INFO] [stdout]  6 | |     c := "str",
[INFO] [stdout]  7 | |     d := 'c'
[INFO] [stdout]  8 | | ));
[INFO] [stdout]    | |__- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(global_variables => (
[INFO] [stdout]  4 | |     a := 1,
[INFO] [stdout]  5 | |     b := true,
[INFO] [stdout]  6 | |     c := "str",
[INFO] [stdout]  7 | |     d := 'c'
[INFO] [stdout]  8 | | ));
[INFO] [stdout]    | |__- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:10:1
[INFO] [stdout]    |
[INFO] [stdout] 10 | / test!(math => (
[INFO] [stdout] 11 | |     complex_a := 1,
[INFO] [stdout] 12 | |     complex_b := 2.5,
[INFO] [stdout] 13 | |     complex_c := 6,
[INFO] [stdout] ...  |
[INFO] [stdout] 35 | |     large_overflow := 1e36
[INFO] [stdout] 36 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:38:1
[INFO] [stdout]    |
[INFO] [stdout] 38 | / test!(operators => (
[INFO] [stdout] 39 | |     n_eq := true,
[INFO] [stdout] 40 | |     n_neq := true,
[INFO] [stdout] 41 | |     n_add := 2,
[INFO] [stdout] ...  |
[INFO] [stdout] 54 | |     c_neq := true
[INFO] [stdout] 55 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:57:1
[INFO] [stdout]    |
[INFO] [stdout] 57 | / test!(operators_precedence => (
[INFO] [stdout] 58 | |     a := 8,
[INFO] [stdout] 59 | |     b := true,
[INFO] [stdout] 60 | |     c := true,
[INFO] [stdout] 61 | |     d := true
[INFO] [stdout] 62 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:57:1
[INFO] [stdout]    |
[INFO] [stdout] 57 | / test!(operators_precedence => (
[INFO] [stdout] 58 | |     a := 8,
[INFO] [stdout] 59 | |     b := true,
[INFO] [stdout] 60 | |     c := true,
[INFO] [stdout] 61 | |     d := true
[INFO] [stdout] 62 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:57:1
[INFO] [stdout]    |
[INFO] [stdout] 57 | / test!(operators_precedence => (
[INFO] [stdout] 58 | |     a := 8,
[INFO] [stdout] 59 | |     b := true,
[INFO] [stdout] 60 | |     c := true,
[INFO] [stdout] 61 | |     d := true
[INFO] [stdout] 62 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:57:1
[INFO] [stdout]    |
[INFO] [stdout] 57 | / test!(operators_precedence => (
[INFO] [stdout] 58 | |     a := 8,
[INFO] [stdout] 59 | |     b := true,
[INFO] [stdout] 60 | |     c := true,
[INFO] [stdout] 61 | |     d := true
[INFO] [stdout] 62 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:66:1
[INFO] [stdout]    |
[INFO] [stdout] 66 | / test!(return_complex => (
[INFO] [stdout] 67 | |     nested_res := 1,
[INFO] [stdout] 68 | |     chained_res := 2
[INFO] [stdout] 69 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:66:1
[INFO] [stdout]    |
[INFO] [stdout] 66 | / test!(return_complex => (
[INFO] [stdout] 67 | |     nested_res := 1,
[INFO] [stdout] 68 | |     chained_res := 2
[INFO] [stdout] 69 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:71:1
[INFO] [stdout]    |
[INFO] [stdout] 71 | / test!(ifelse => (
[INFO] [stdout] 72 | |     a := 0
[INFO] [stdout] 73 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:75:1
[INFO] [stdout]    |
[INFO] [stdout] 75 | / test!(comments => (
[INFO] [stdout] 76 | |     x := 42,
[INFO] [stdout] 77 | |     y := 24,
[INFO] [stdout] 78 | |     z := 100
[INFO] [stdout] 79 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:75:1
[INFO] [stdout]    |
[INFO] [stdout] 75 | / test!(comments => (
[INFO] [stdout] 76 | |     x := 42,
[INFO] [stdout] 77 | |     y := 24,
[INFO] [stdout] 78 | |     z := 100
[INFO] [stdout] 79 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:75:1
[INFO] [stdout]    |
[INFO] [stdout] 75 | / test!(comments => (
[INFO] [stdout] 76 | |     x := 42,
[INFO] [stdout] 77 | |     y := 24,
[INFO] [stdout] 78 | |     z := 100
[INFO] [stdout] 79 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:81:1
[INFO] [stdout]    |
[INFO] [stdout] 81 | / test!(comparison_numerical => (
[INFO] [stdout] 82 | |     a := 8
[INFO] [stdout] 83 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:85:1
[INFO] [stdout]    |
[INFO] [stdout] 85 | / test!(comparison_boolean => (
[INFO] [stdout] 86 | |     a := 6
[INFO] [stdout] 87 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/feature/mod.rs:89:1
[INFO] [stdout]    |
[INFO] [stdout] 89 | / test!(comparison_truthy => (
[INFO] [stdout] 90 | |     a := 4
[INFO] [stdout] 91 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:93:1
[INFO] [stdout]     |
[INFO] [stdout]  93 | / test!(compound_assign => (
[INFO] [stdout]  94 | |     n_add := 5,
[INFO] [stdout]  95 | |     n_sub := 7,
[INFO] [stdout]  96 | |     n_mul := 12,
[INFO] [stdout] ...   |
[INFO] [stdout]  99 | |     n_deref := 10
[INFO] [stdout] 100 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | / test!(functions => (
[INFO] [stdout] 103 | |     a := 10,
[INFO] [stdout] 104 | |     b := 20,
[INFO] [stdout] 105 | |     c := true,
[INFO] [stdout] 106 | |     d := 300
[INFO] [stdout] 107 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | / test!(functions => (
[INFO] [stdout] 103 | |     a := 10,
[INFO] [stdout] 104 | |     b := 20,
[INFO] [stdout] 105 | |     c := true,
[INFO] [stdout] 106 | |     d := 300
[INFO] [stdout] 107 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | / test!(functions => (
[INFO] [stdout] 103 | |     a := 10,
[INFO] [stdout] 104 | |     b := 20,
[INFO] [stdout] 105 | |     c := true,
[INFO] [stdout] 106 | |     d := 300
[INFO] [stdout] 107 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | / test!(functions => (
[INFO] [stdout] 103 | |     a := 10,
[INFO] [stdout] 104 | |     b := 20,
[INFO] [stdout] 105 | |     c := true,
[INFO] [stdout] 106 | |     d := 300
[INFO] [stdout] 107 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:109:1
[INFO] [stdout]     |
[INFO] [stdout] 109 | / test!(functions_arg_copy => (
[INFO] [stdout] 110 | |     x := 5,
[INFO] [stdout] 111 | |     modified := 105
[INFO] [stdout] 112 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:109:1
[INFO] [stdout]     |
[INFO] [stdout] 109 | / test!(functions_arg_copy => (
[INFO] [stdout] 110 | |     x := 5,
[INFO] [stdout] 111 | |     modified := 105
[INFO] [stdout] 112 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:122:1
[INFO] [stdout]     |
[INFO] [stdout] 122 | / test!(functions_by_ref => (
[INFO] [stdout] 123 | |     res := 2
[INFO] [stdout] 124 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 | / test!(functions_truthy => (
[INFO] [stdout] 127 | |     is_truthy := true
[INFO] [stdout] 128 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 | / test!(functions_zero_args => (
[INFO] [stdout] 131 | |     result := "hello",
[INFO] [stdout] 132 | |     num := 42
[INFO] [stdout] 133 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 | / test!(functions_zero_args => (
[INFO] [stdout] 131 | |     result := "hello",
[INFO] [stdout] 132 | |     num := 42
[INFO] [stdout] 133 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:135:1
[INFO] [stdout]     |
[INFO] [stdout] 135 | / test!(loops => (
[INFO] [stdout] 136 | |     x := 25
[INFO] [stdout] 137 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:139:1
[INFO] [stdout]     |
[INFO] [stdout] 139 | / test!(loops_break => (
[INFO] [stdout] 140 | |     x := 1
[INFO] [stdout] 141 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:145:1
[INFO] [stdout]     |
[INFO] [stdout] 145 | / test!(loops_nested => (
[INFO] [stdout] 146 | |     x := 25
[INFO] [stdout] 147 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:149:1
[INFO] [stdout]     |
[INFO] [stdout] 149 | / test!(indices_dangling => (
[INFO] [stdout] 150 | |     dangling := 10
[INFO] [stdout] 151 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:153:1
[INFO] [stdout]     |
[INFO] [stdout] 153 | / test!(indices_indirect => (
[INFO] [stdout] 154 | |     read := 5,
[INFO] [stdout] 155 | |     write := 0
[INFO] [stdout] 156 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:153:1
[INFO] [stdout]     |
[INFO] [stdout] 153 | / test!(indices_indirect => (
[INFO] [stdout] 154 | |     read := 5,
[INFO] [stdout] 155 | |     write := 0
[INFO] [stdout] 156 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:158:1
[INFO] [stdout]     |
[INFO] [stdout] 158 | / test!(indices_assignment => (
[INFO] [stdout] 159 | |     result == node!([
[INFO] [stdout] 160 | |         lit!(999),
[INFO] [stdout] 161 | |         lit!(777),
[INFO] [stdout] 162 | |         lit!(300)
[INFO] [stdout] 163 | |     ])
[INFO] [stdout] 164 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:170:1
[INFO] [stdout]     |
[INFO] [stdout] 170 | / test!(indices_nested => (
[INFO] [stdout] 171 | |     nest_0 == node!([lit!(123), lit!(321)]),
[INFO] [stdout] 172 | |     nest_1 := 123,
[INFO] [stdout] 173 | |     nest_2 := 321,
[INFO] [stdout] 174 | |     nest_3 := true
[INFO] [stdout] 175 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:170:1
[INFO] [stdout]     |
[INFO] [stdout] 170 | / test!(indices_nested => (
[INFO] [stdout] 171 | |     nest_0 == node!([lit!(123), lit!(321)]),
[INFO] [stdout] 172 | |     nest_1 := 123,
[INFO] [stdout] 173 | |     nest_2 := 321,
[INFO] [stdout] 174 | |     nest_3 := true
[INFO] [stdout] 175 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:170:1
[INFO] [stdout]     |
[INFO] [stdout] 170 | / test!(indices_nested => (
[INFO] [stdout] 171 | |     nest_0 == node!([lit!(123), lit!(321)]),
[INFO] [stdout] 172 | |     nest_1 := 123,
[INFO] [stdout] 173 | |     nest_2 := 321,
[INFO] [stdout] 174 | |     nest_3 := true
[INFO] [stdout] 175 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:170:1
[INFO] [stdout]     |
[INFO] [stdout] 170 | / test!(indices_nested => (
[INFO] [stdout] 171 | |     nest_0 == node!([lit!(123), lit!(321)]),
[INFO] [stdout] 172 | |     nest_1 := 123,
[INFO] [stdout] 173 | |     nest_2 := 321,
[INFO] [stdout] 174 | |     nest_3 := true
[INFO] [stdout] 175 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:183:1
[INFO] [stdout]     |
[INFO] [stdout] 183 | / test!(lists => (
[INFO] [stdout] 184 | |     empty == node!([]),
[INFO] [stdout] 185 | |     nested_empty == node!([node!([node!([node!([])])])]),
[INFO] [stdout] 186 | |     spread == node!([lit!(1), lit!(2), lit!(3)]),
[INFO] [stdout] 187 | |     spread_empty == node!([node!([]), node!([]), node!([])]),
[INFO] [stdout] 188 | |     spread_nested == node!([node!([lit!(1), lit!(2), lit!(3)])])
[INFO] [stdout] 189 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:183:1
[INFO] [stdout]     |
[INFO] [stdout] 183 | / test!(lists => (
[INFO] [stdout] 184 | |     empty == node!([]),
[INFO] [stdout] 185 | |     nested_empty == node!([node!([node!([node!([])])])]),
[INFO] [stdout] 186 | |     spread == node!([lit!(1), lit!(2), lit!(3)]),
[INFO] [stdout] 187 | |     spread_empty == node!([node!([]), node!([]), node!([])]),
[INFO] [stdout] 188 | |     spread_nested == node!([node!([lit!(1), lit!(2), lit!(3)])])
[INFO] [stdout] 189 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:183:1
[INFO] [stdout]     |
[INFO] [stdout] 183 | / test!(lists => (
[INFO] [stdout] 184 | |     empty == node!([]),
[INFO] [stdout] 185 | |     nested_empty == node!([node!([node!([node!([])])])]),
[INFO] [stdout] 186 | |     spread == node!([lit!(1), lit!(2), lit!(3)]),
[INFO] [stdout] 187 | |     spread_empty == node!([node!([]), node!([]), node!([])]),
[INFO] [stdout] 188 | |     spread_nested == node!([node!([lit!(1), lit!(2), lit!(3)])])
[INFO] [stdout] 189 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:183:1
[INFO] [stdout]     |
[INFO] [stdout] 183 | / test!(lists => (
[INFO] [stdout] 184 | |     empty == node!([]),
[INFO] [stdout] 185 | |     nested_empty == node!([node!([node!([node!([])])])]),
[INFO] [stdout] 186 | |     spread == node!([lit!(1), lit!(2), lit!(3)]),
[INFO] [stdout] 187 | |     spread_empty == node!([node!([]), node!([]), node!([])]),
[INFO] [stdout] 188 | |     spread_nested == node!([node!([lit!(1), lit!(2), lit!(3)])])
[INFO] [stdout] 189 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:183:1
[INFO] [stdout]     |
[INFO] [stdout] 183 | / test!(lists => (
[INFO] [stdout] 184 | |     empty == node!([]),
[INFO] [stdout] 185 | |     nested_empty == node!([node!([node!([node!([])])])]),
[INFO] [stdout] 186 | |     spread == node!([lit!(1), lit!(2), lit!(3)]),
[INFO] [stdout] 187 | |     spread_empty == node!([node!([]), node!([]), node!([])]),
[INFO] [stdout] 188 | |     spread_nested == node!([node!([lit!(1), lit!(2), lit!(3)])])
[INFO] [stdout] 189 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:191:1
[INFO] [stdout]     |
[INFO] [stdout] 191 | / test!(lists_concat => (
[INFO] [stdout] 192 | |     simple == node!([lit!(1), lit!(2), lit!(3), lit!(4)]),
[INFO] [stdout] 193 | |     empty_left == node!([lit!(1), lit!(2)]),
[INFO] [stdout] 194 | |     empty_right == node!([lit!(1), lit!(2)]),
[INFO] [stdout] ...   |
[INFO] [stdout] 198 | |     chained == node!([lit!(1), lit!(2), lit!(3)])
[INFO] [stdout] 199 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:203:1
[INFO] [stdout]     |
[INFO] [stdout] 203 | / test!(lists_with_indices => (
[INFO] [stdout] 204 | |     source == node!([lit!(10), lit!(20), lit!(30)]),
[INFO] [stdout] 205 | |     with_index == node!([lit!(20)]),
[INFO] [stdout] 206 | |     with_many_index == node!([lit!(10), lit!(30)]),
[INFO] [stdout] 207 | |     with_nested_index == node!([node!([node!([lit!(20)])])])
[INFO] [stdout] 208 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:203:1
[INFO] [stdout]     |
[INFO] [stdout] 203 | / test!(lists_with_indices => (
[INFO] [stdout] 204 | |     source == node!([lit!(10), lit!(20), lit!(30)]),
[INFO] [stdout] 205 | |     with_index == node!([lit!(20)]),
[INFO] [stdout] 206 | |     with_many_index == node!([lit!(10), lit!(30)]),
[INFO] [stdout] 207 | |     with_nested_index == node!([node!([node!([lit!(20)])])])
[INFO] [stdout] 208 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:203:1
[INFO] [stdout]     |
[INFO] [stdout] 203 | / test!(lists_with_indices => (
[INFO] [stdout] 204 | |     source == node!([lit!(10), lit!(20), lit!(30)]),
[INFO] [stdout] 205 | |     with_index == node!([lit!(20)]),
[INFO] [stdout] 206 | |     with_many_index == node!([lit!(10), lit!(30)]),
[INFO] [stdout] 207 | |     with_nested_index == node!([node!([node!([lit!(20)])])])
[INFO] [stdout] 208 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:203:1
[INFO] [stdout]     |
[INFO] [stdout] 203 | / test!(lists_with_indices => (
[INFO] [stdout] 204 | |     source == node!([lit!(10), lit!(20), lit!(30)]),
[INFO] [stdout] 205 | |     with_index == node!([lit!(20)]),
[INFO] [stdout] 206 | |     with_many_index == node!([lit!(10), lit!(30)]),
[INFO] [stdout] 207 | |     with_nested_index == node!([node!([node!([lit!(20)])])])
[INFO] [stdout] 208 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:210:1
[INFO] [stdout]     |
[INFO] [stdout] 210 | / test!(imports => (
[INFO] [stdout] 211 | |     get_res := 4,
[INFO] [stdout] 212 | |     assign_res := "reassignment value",
[INFO] [stdout] 213 | |     decl_res := "declaration value",
[INFO] [stdout] 214 | |     outer_res := true
[INFO] [stdout] 215 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:210:1
[INFO] [stdout]     |
[INFO] [stdout] 210 | / test!(imports => (
[INFO] [stdout] 211 | |     get_res := 4,
[INFO] [stdout] 212 | |     assign_res := "reassignment value",
[INFO] [stdout] 213 | |     decl_res := "declaration value",
[INFO] [stdout] 214 | |     outer_res := true
[INFO] [stdout] 215 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:210:1
[INFO] [stdout]     |
[INFO] [stdout] 210 | / test!(imports => (
[INFO] [stdout] 211 | |     get_res := 4,
[INFO] [stdout] 212 | |     assign_res := "reassignment value",
[INFO] [stdout] 213 | |     decl_res := "declaration value",
[INFO] [stdout] 214 | |     outer_res := true
[INFO] [stdout] 215 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:210:1
[INFO] [stdout]     |
[INFO] [stdout] 210 | / test!(imports => (
[INFO] [stdout] 211 | |     get_res := 4,
[INFO] [stdout] 212 | |     assign_res := "reassignment value",
[INFO] [stdout] 213 | |     decl_res := "declaration value",
[INFO] [stdout] 214 | |     outer_res := true
[INFO] [stdout] 215 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / test!(string_index => (
[INFO] [stdout] 218 | |     head := '0',
[INFO] [stdout] 219 | |     tail := '5'
[INFO] [stdout] 220 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / test!(string_index => (
[INFO] [stdout] 218 | |     head := '0',
[INFO] [stdout] 219 | |     tail := '5'
[INFO] [stdout] 220 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:224:1
[INFO] [stdout]     |
[INFO] [stdout] 224 | / test!(string_concat => (
[INFO] [stdout] 225 | |     str_concat := "abcd",
[INFO] [stdout] 226 | |     str_chain := "abcd",
[INFO] [stdout] 227 | |     num_concat := "123",
[INFO] [stdout] ...   |
[INFO] [stdout] 231 | |     unicode_str := "🔥🔥"
[INFO] [stdout] 232 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:234:1
[INFO] [stdout]     |
[INFO] [stdout] 234 | / test!(nested_imports => (
[INFO] [stdout] 235 | |     res := 4
[INFO] [stdout] 236 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / test!(struct_constructors => (
[INFO] [stdout] 239 | |     av := 444,
[INFO] [stdout] 240 | |     bv := 0,
[INFO] [stdout] 241 | |     declaration := true
[INFO] [stdout] 242 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / test!(struct_constructors => (
[INFO] [stdout] 239 | |     av := 444,
[INFO] [stdout] 240 | |     bv := 0,
[INFO] [stdout] 241 | |     declaration := true
[INFO] [stdout] 242 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / test!(struct_constructors => (
[INFO] [stdout] 239 | |     av := 444,
[INFO] [stdout] 240 | |     bv := 0,
[INFO] [stdout] 241 | |     declaration := true
[INFO] [stdout] 242 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:244:1
[INFO] [stdout]     |
[INFO] [stdout] 244 | / test!(struct_functions => (
[INFO] [stdout] 245 | |     add := 10,
[INFO] [stdout] 246 | |     sub := 0,
[INFO] [stdout] 247 | |     last := 0
[INFO] [stdout] 248 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:244:1
[INFO] [stdout]     |
[INFO] [stdout] 244 | / test!(struct_functions => (
[INFO] [stdout] 245 | |     add := 10,
[INFO] [stdout] 246 | |     sub := 0,
[INFO] [stdout] 247 | |     last := 0
[INFO] [stdout] 248 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:244:1
[INFO] [stdout]     |
[INFO] [stdout] 244 | / test!(struct_functions => (
[INFO] [stdout] 245 | |     add := 10,
[INFO] [stdout] 246 | |     sub := 0,
[INFO] [stdout] 247 | |     last := 0
[INFO] [stdout] 248 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:250:1
[INFO] [stdout]     |
[INFO] [stdout] 250 | / test!(struct_nested_method_call => (
[INFO] [stdout] 251 | |     inc1 := 42,
[INFO] [stdout] 252 | |     val1 := 42,
[INFO] [stdout] 253 | |     inc2 := 43,
[INFO] [stdout] 254 | |     val2 := 43
[INFO] [stdout] 255 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:250:1
[INFO] [stdout]     |
[INFO] [stdout] 250 | / test!(struct_nested_method_call => (
[INFO] [stdout] 251 | |     inc1 := 42,
[INFO] [stdout] 252 | |     val1 := 42,
[INFO] [stdout] 253 | |     inc2 := 43,
[INFO] [stdout] 254 | |     val2 := 43
[INFO] [stdout] 255 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:250:1
[INFO] [stdout]     |
[INFO] [stdout] 250 | / test!(struct_nested_method_call => (
[INFO] [stdout] 251 | |     inc1 := 42,
[INFO] [stdout] 252 | |     val1 := 42,
[INFO] [stdout] 253 | |     inc2 := 43,
[INFO] [stdout] 254 | |     val2 := 43
[INFO] [stdout] 255 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:250:1
[INFO] [stdout]     |
[INFO] [stdout] 250 | / test!(struct_nested_method_call => (
[INFO] [stdout] 251 | |     inc1 := 42,
[INFO] [stdout] 252 | |     val1 := 42,
[INFO] [stdout] 253 | |     inc2 := 43,
[INFO] [stdout] 254 | |     val2 := 43
[INFO] [stdout] 255 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:257:1
[INFO] [stdout]     |
[INFO] [stdout] 257 | / test!(struct_zero_fields => (
[INFO] [stdout] 258 | |     value := 99
[INFO] [stdout] 259 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:261:1
[INFO] [stdout]     |
[INFO] [stdout] 261 | / test!(struct_builtins => (
[INFO] [stdout] 262 | |     result := 3,
[INFO] [stdout] 263 | |     method_result := 3
[INFO] [stdout] 264 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:261:1
[INFO] [stdout]     |
[INFO] [stdout] 261 | / test!(struct_builtins => (
[INFO] [stdout] 262 | |     result := 3,
[INFO] [stdout] 263 | |     method_result := 3
[INFO] [stdout] 264 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:266:1
[INFO] [stdout]     |
[INFO] [stdout] 266 | / test!(struct_global_function_call => (
[INFO] [stdout] 267 | |     result := 10
[INFO] [stdout] 268 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:270:1
[INFO] [stdout]     |
[INFO] [stdout] 270 | / test!(struct_global_type_instantiation => (
[INFO] [stdout] 271 | |     result := 5
[INFO] [stdout] 272 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:274:1
[INFO] [stdout]     |
[INFO] [stdout] 274 | / test!(struct_global_variable_read => (
[INFO] [stdout] 275 | |     result := 10
[INFO] [stdout] 276 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:278:1
[INFO] [stdout]     |
[INFO] [stdout] 278 | / test!(unary => (
[INFO] [stdout] 279 | |     v := true,
[INFO] [stdout] 280 | |     not_v := false,
[INFO] [stdout] 281 | |     complex_not_a := true,
[INFO] [stdout] 282 | |     complex_not_b := false,
[INFO] [stdout] 283 | |     complex_not_c := false
[INFO] [stdout] 284 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:278:1
[INFO] [stdout]     |
[INFO] [stdout] 278 | / test!(unary => (
[INFO] [stdout] 279 | |     v := true,
[INFO] [stdout] 280 | |     not_v := false,
[INFO] [stdout] 281 | |     complex_not_a := true,
[INFO] [stdout] 282 | |     complex_not_b := false,
[INFO] [stdout] 283 | |     complex_not_c := false
[INFO] [stdout] 284 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:278:1
[INFO] [stdout]     |
[INFO] [stdout] 278 | / test!(unary => (
[INFO] [stdout] 279 | |     v := true,
[INFO] [stdout] 280 | |     not_v := false,
[INFO] [stdout] 281 | |     complex_not_a := true,
[INFO] [stdout] 282 | |     complex_not_b := false,
[INFO] [stdout] 283 | |     complex_not_c := false
[INFO] [stdout] 284 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:278:1
[INFO] [stdout]     |
[INFO] [stdout] 278 | / test!(unary => (
[INFO] [stdout] 279 | |     v := true,
[INFO] [stdout] 280 | |     not_v := false,
[INFO] [stdout] 281 | |     complex_not_a := true,
[INFO] [stdout] 282 | |     complex_not_b := false,
[INFO] [stdout] 283 | |     complex_not_c := false
[INFO] [stdout] 284 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:278:1
[INFO] [stdout]     |
[INFO] [stdout] 278 | / test!(unary => (
[INFO] [stdout] 279 | |     v := true,
[INFO] [stdout] 280 | |     not_v := false,
[INFO] [stdout] 281 | |     complex_not_a := true,
[INFO] [stdout] 282 | |     complex_not_b := false,
[INFO] [stdout] 283 | |     complex_not_c := false
[INFO] [stdout] 284 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:286:1
[INFO] [stdout]     |
[INFO] [stdout] 286 | / test!(unary_call_deref => (
[INFO] [stdout] 287 | |     neg := -5,
[INFO] [stdout] 288 | |     flipped := false
[INFO] [stdout] 289 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:286:1
[INFO] [stdout]     |
[INFO] [stdout] 286 | / test!(unary_call_deref => (
[INFO] [stdout] 287 | |     neg := -5,
[INFO] [stdout] 288 | |     flipped := false
[INFO] [stdout] 289 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:291:1
[INFO] [stdout]     |
[INFO] [stdout] 291 | / test!(unary_list_deref => (
[INFO] [stdout] 292 | |     list == node!([lit!(2), lit!(0), lit!(1)]),
[INFO] [stdout] 293 | |     negate := -1
[INFO] [stdout] 294 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:291:1
[INFO] [stdout]     |
[INFO] [stdout] 291 | / test!(unary_list_deref => (
[INFO] [stdout] 292 | |     list == node!([lit!(2), lit!(0), lit!(1)]),
[INFO] [stdout] 293 | |     negate := -1
[INFO] [stdout] 294 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:296:1
[INFO] [stdout]     |
[INFO] [stdout] 296 | / test!(unary_struct_deref => (
[INFO] [stdout] 297 | |     after_inc := 6,
[INFO] [stdout] 298 | |     after_dec := 4,
[INFO] [stdout] 299 | |     negate := -4
[INFO] [stdout] 300 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:296:1
[INFO] [stdout]     |
[INFO] [stdout] 296 | / test!(unary_struct_deref => (
[INFO] [stdout] 297 | |     after_inc := 6,
[INFO] [stdout] 298 | |     after_dec := 4,
[INFO] [stdout] 299 | |     negate := -4
[INFO] [stdout] 300 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:296:1
[INFO] [stdout]     |
[INFO] [stdout] 296 | / test!(unary_struct_deref => (
[INFO] [stdout] 297 | |     after_inc := 6,
[INFO] [stdout] 298 | |     after_dec := 4,
[INFO] [stdout] 299 | |     negate := -4
[INFO] [stdout] 300 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:302:1
[INFO] [stdout]     |
[INFO] [stdout] 302 | / test!(call_deref => (
[INFO] [stdout] 303 | |     px := 10,
[INFO] [stdout] 304 | |     py := 20
[INFO] [stdout] 305 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:302:1
[INFO] [stdout]     |
[INFO] [stdout] 302 | / test!(call_deref => (
[INFO] [stdout] 303 | |     px := 10,
[INFO] [stdout] 304 | |     py := 20
[INFO] [stdout] 305 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]    --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]     |
[INFO] [stdout]  12 | / macro_rules! var_eq {
[INFO] [stdout]  13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout]  14 | |         let (got, expected) = (
[INFO] [stdout]  15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout]  16 | |             Variable::Owned($node).into(),
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout]  24 | |     };
[INFO] [stdout]  25 | | }
[INFO] [stdout]     | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]     |
[INFO] [stdout]    ::: lylib/src/interpreter/tests/feature/mod.rs:307:1
[INFO] [stdout]     |
[INFO] [stdout] 307 | / test!(logical_ops => (
[INFO] [stdout] 308 | |     and_tt := true,
[INFO] [stdout] 309 | |     and_tf := false,
[INFO] [stdout] 310 | |     and_ft := false,
[INFO] [stdout] ...   |
[INFO] [stdout] 324 | |     cmp_b := true
[INFO] [stdout] 325 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(binary_search => (
[INFO] [stdout]  4 | |     some := 4,
[INFO] [stdout]  5 | |     none := -1
[INFO] [stdout]  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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:3:1
[INFO] [stdout]    |
[INFO] [stdout]  3 | / test!(binary_search => (
[INFO] [stdout]  4 | |     some := 4,
[INFO] [stdout]  5 | |     none := -1
[INFO] [stdout]  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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:8:1
[INFO] [stdout]    |
[INFO] [stdout]  8 | / test!(tree => (
[INFO] [stdout]  9 | |     head := 1,
[INFO] [stdout] 10 | |     l_value := 2,
[INFO] [stdout] 11 | |     l_r_value := 3,
[INFO] [stdout] 12 | |     l_r_r_value := 4,
[INFO] [stdout] 13 | |     dne := true
[INFO] [stdout] 14 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:8:1
[INFO] [stdout]    |
[INFO] [stdout]  8 | / test!(tree => (
[INFO] [stdout]  9 | |     head := 1,
[INFO] [stdout] 10 | |     l_value := 2,
[INFO] [stdout] 11 | |     l_r_value := 3,
[INFO] [stdout] 12 | |     l_r_r_value := 4,
[INFO] [stdout] 13 | |     dne := true
[INFO] [stdout] 14 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:8:1
[INFO] [stdout]    |
[INFO] [stdout]  8 | / test!(tree => (
[INFO] [stdout]  9 | |     head := 1,
[INFO] [stdout] 10 | |     l_value := 2,
[INFO] [stdout] 11 | |     l_r_value := 3,
[INFO] [stdout] 12 | |     l_r_r_value := 4,
[INFO] [stdout] 13 | |     dne := true
[INFO] [stdout] 14 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:8:1
[INFO] [stdout]    |
[INFO] [stdout]  8 | / test!(tree => (
[INFO] [stdout]  9 | |     head := 1,
[INFO] [stdout] 10 | |     l_value := 2,
[INFO] [stdout] 11 | |     l_r_value := 3,
[INFO] [stdout] 12 | |     l_r_r_value := 4,
[INFO] [stdout] 13 | |     dne := true
[INFO] [stdout] 14 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:8:1
[INFO] [stdout]    |
[INFO] [stdout]  8 | / test!(tree => (
[INFO] [stdout]  9 | |     head := 1,
[INFO] [stdout] 10 | |     l_value := 2,
[INFO] [stdout] 11 | |     l_r_value := 3,
[INFO] [stdout] 12 | |     l_r_r_value := 4,
[INFO] [stdout] 13 | |     dne := true
[INFO] [stdout] 14 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:16:1
[INFO] [stdout]    |
[INFO] [stdout] 16 | / test!(fibonacci => (
[INFO] [stdout] 17 | |     result := 21
[INFO] [stdout] 18 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:20:1
[INFO] [stdout]    |
[INFO] [stdout] 20 | / test!(factorial => (
[INFO] [stdout] 21 | |     six_fac := 720,
[INFO] [stdout] 22 | |     one_fac := 1,
[INFO] [stdout] 23 | |     zero_fac := 1
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:20:1
[INFO] [stdout]    |
[INFO] [stdout] 20 | / test!(factorial => (
[INFO] [stdout] 21 | |     six_fac := 720,
[INFO] [stdout] 22 | |     one_fac := 1,
[INFO] [stdout] 23 | |     zero_fac := 1
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:20:1
[INFO] [stdout]    |
[INFO] [stdout] 20 | / test!(factorial => (
[INFO] [stdout] 21 | |     six_fac := 720,
[INFO] [stdout] 22 | |     one_fac := 1,
[INFO] [stdout] 23 | |     zero_fac := 1
[INFO] [stdout] 24 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:26:1
[INFO] [stdout]    |
[INFO] [stdout] 26 | / test!(matrix_rotation => (
[INFO] [stdout] 27 | |     matrix_a == node!([
[INFO] [stdout] 28 | |         node!([lit!(1), lit!(4), lit!(7)]),
[INFO] [stdout] 29 | |         node!([lit!(2), lit!(5), lit!(8)]),
[INFO] [stdout] ...  |
[INFO] [stdout] 36 | |     ])
[INFO] [stdout] 37 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `variable::Variable`
[INFO] [stdout]   --> lylib/src/interpreter/tests/mod.rs:16:13
[INFO] [stdout]    |
[INFO] [stdout] 12 | / macro_rules! var_eq {
[INFO] [stdout] 13 | |     ($interpreter:expr, $id:tt, $node:expr) => {
[INFO] [stdout] 14 | |         let (got, expected) = (
[INFO] [stdout] 15 | |             $interpreter.get(&stringify!($id).as_id()).unwrap(),
[INFO] [stdout] 16 | |             Variable::Owned($node).into(),
[INFO] [stdout]    | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...  |
[INFO] [stdout] 24 | |     };
[INFO] [stdout] 25 | | }
[INFO] [stdout]    | |_- this error originates in the macro `var_eq` which comes from the expansion of the macro `test`
[INFO] [stdout]    |
[INFO] [stdout]   ::: lylib/src/interpreter/tests/implementation/mod.rs:26:1
[INFO] [stdout]    |
[INFO] [stdout] 26 | / test!(matrix_rotation => (
[INFO] [stdout] 27 | |     matrix_a == node!([
[INFO] [stdout] 28 | |         node!([lit!(1), lit!(4), lit!(7)]),
[INFO] [stdout] 29 | |         node!([lit!(2), lit!(5), lit!(8)]),
[INFO] [stdout] ...  |
[INFO] [stdout] 36 | |     ])
[INFO] [stdout] 37 | | ));
[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 `<variable::Variable as Into<variable::Variable>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `lylib` (lib test) due to 195 previous errors
[INFO] running `Command { std: "docker" "inspect" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd", kill_on_drop: false }`
[INFO] [stdout] c0fd85c8209cc038b85562ae17cd69375a7dcd2686e3751972c9100d07aef4bd
