[INFO] cloning repository https://github.com/jprendes/picomeson
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/jprendes/picomeson" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fjprendes%2Fpicomeson", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fjprendes%2Fpicomeson'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] fed476a17739b90a87ed98b60a3b5ddd3490866c
[INFO] checking jprendes/picomeson against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fjprendes%2Fpicomeson" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/jprendes/picomeson
[INFO] finished tweaking git repo https://github.com/jprendes/picomeson
[INFO] tweaked toml for git repo https://github.com/jprendes/picomeson written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/jprendes/picomeson on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/jprendes/picomeson already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:18:12
[INFO] [stderr]    |
[INFO] [stderr] 18 | homepage = "https://github.com/jprendes/picomeson"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 22 | repository = "https://github.com/jprendes/picomeson"
[INFO] [stderr]    |              ---------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `picomeson` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d
[INFO] running `Command { std: "docker" "start" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d", 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" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d", 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" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:18:12
[INFO] [stderr]    |
[INFO] [stderr] 18 | homepage = "https://github.com/jprendes/picomeson"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 22 | repository = "https://github.com/jprendes/picomeson"
[INFO] [stderr]    |              ---------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `picomeson` (manifest) generated 1 warning
[INFO] [stderr]    Compiling proc-macro2 v1.0.101
[INFO] [stderr]    Compiling unicode-ident v1.0.19
[INFO] [stderr]    Compiling anyhow v1.0.99
[INFO] [stderr]    Compiling rustix v1.0.8
[INFO] [stderr]    Compiling libc v0.2.175
[INFO] [stderr]    Compiling semver v1.0.26
[INFO] [stderr]     Checking anstyle v1.0.11
[INFO] [stderr]     Checking anstyle-query v1.1.4
[INFO] [stderr]     Checking is_terminal_polyfill v1.70.1
[INFO] [stderr]     Checking bitflags v2.9.4
[INFO] [stderr]     Checking linux-raw-sys v0.9.4
[INFO] [stderr]    Compiling getrandom v0.3.3
[INFO] [stderr]     Checking foldhash v0.2.0
[INFO] [stderr]     Checking as-any v0.3.2
[INFO] [stderr]     Checking clap_lex v0.7.5
[INFO] [stderr]     Checking cfg-if v1.0.3
[INFO] [stderr]     Checking env_home v0.1.0
[INFO] [stderr]     Checking fastrand v2.3.0
[INFO] [stderr]     Checking once_cell v1.21.3
[INFO] [stderr]     Checking hashbrown v0.16.0
[INFO] [stderr]     Checking anstream v0.6.20
[INFO] [stderr]     Checking clap_builder v4.5.47
[INFO] [stderr]    Compiling quote v1.0.40
[INFO] [stderr]    Compiling syn v2.0.106
[INFO] [stderr]     Checking picomeson v0.1.3 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/build_target.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 73 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::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: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/build_target.rs:77:5
[INFO] [stdout]    |
[INFO] [stdout] 77 |       builtin_impl!(extract_objects, extract_all_objects, full_path);
[INFO] [stdout]    |       -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:27:5
[INFO] [stdout]    |
[INFO] [stdout] 27 | /     builtin_impl!(
[INFO] [stdout] 28 | |         get_id,
[INFO] [stdout] 29 | |         get_linker_id,
[INFO] [stdout] 30 | |         cmd_array,
[INFO] [stdout] ...  |
[INFO] [stdout] 38 | |         links,
[INFO] [stdout] 39 | |     );
[INFO] [stdout]    | |_____- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:107:13
[INFO] [stdout]     |
[INFO] [stdout] 107 |             bail_runtime_error!("Compiler does not support argument: {argument}");
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:21:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | macro_rules! bail_runtime_error {
[INFO] [stdout] 20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/config_data.rs:35:21
[INFO] [stdout]    |
[INFO] [stdout] 35 |             None => bail_runtime_error!("Key '{key}' not found in ConfigData"),
[INFO] [stdout]    |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | / macro_rules! bail_runtime_error {
[INFO] [stdout]  20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]  22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout]  23 | | }
[INFO] [stdout]     | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:125:5
[INFO] [stdout]     |
[INFO] [stdout] 125 |       builtin_impl!(get, set, set10, merge_from);
[INFO] [stdout]     |       ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:272:13
[INFO] [stdout]     |
[INFO] [stdout] 272 | /             bail_runtime_error!(
[INFO] [stdout] 273 | |                 "configure_file: The following placeholders were not replaced: {}",
[INFO] [stdout] 274 | |                 unreplaced.join(", ")
[INFO] [stdout] 275 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/env.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |       builtin_impl!(prepend);
[INFO] [stdout]    |       ---------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/external_program.rs:41:5
[INFO] [stdout]    |
[INFO] [stdout] 41 |       builtin_impl!(found, full_path);
[INFO] [stdout]    |       ------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/files.rs:24:5
[INFO] [stdout]    |
[INFO] [stdout] 24 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/filesystem.rs:15:5
[INFO] [stdout]    |
[INFO] [stdout] 15 |       builtin_impl!(replace_suffix, exists, is_file, is_dir);
[INFO] [stdout]    |       ------------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:21:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | macro_rules! bail_runtime_error {
[INFO] [stdout] 20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/import.rs:22:14
[INFO] [stdout]    |
[INFO] [stdout] 22 |         _ => bail_runtime_error!("No module named '{module_name}'"),
[INFO] [stdout]    |              ------------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/include_directories.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/machine.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 |       builtin_impl!(system, cpu_family, cpu, endian);
[INFO] [stdout]    |       ---------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/meson.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 | /     builtin_impl!(
[INFO] [stdout] 21 | |         version,
[INFO] [stdout] 22 | |         is_subproject,
[INFO] [stdout] 23 | |         get_compiler,
[INFO] [stdout] ...  |
[INFO] [stdout] 28 | |         current_source_dir
[INFO] [stdout] 29 | |     );
[INFO] [stdout]    | |_____- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/run_result.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 |       builtin_impl!(stdout, stderr, returncode);
[INFO] [stdout]    |       ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/version.rs:37:5
[INFO] [stdout]    |
[INFO] [stdout] 37 |       builtin_impl!(version_compare);
[INFO] [stdout]    |       ------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:545:22
[INFO] [stdout]     |
[INFO] [stdout] 545 |                 _ => bail_runtime_error!("Unknown method '{method}' for string"),
[INFO] [stdout]     |                      ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:551:22
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 _ => bail_runtime_error!("Unknown method '{method}' for array"),
[INFO] [stdout]     |                      ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:558:22
[INFO] [stdout]     |
[INFO] [stdout] 558 |                 _ => bail_runtime_error!("Unknown method '{method}' for dict"),
[INFO] [stdout]     |                      --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:591:29
[INFO] [stdout]     |
[INFO] [stdout] 591 | ...                   bail_runtime_error!("Division by zero");
[INFO] [stdout]     |                       --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:607:25
[INFO] [stdout]     |
[INFO] [stdout] 607 |                         bail_runtime_error!("Modulo by zero");
[INFO] [stdout]     |                         ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:759:13
[INFO] [stdout]     |
[INFO] [stdout] 759 | /             bail_runtime_error!(
[INFO] [stdout] 760 | |                 "Option '{name}' is not defined. Available options: {:?}",
[INFO] [stdout] 761 | |                 self.options.keys().collect::<Vec<_>>()
[INFO] [stdout] 762 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |       ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:782:21
[INFO] [stdout]     |
[INFO] [stdout] 782 | /                     bail_runtime_error!(
[INFO] [stdout] 783 | |                         "Invalid value '{value}' for string option '{name}', allowed values are: {choices:?}"
[INFO] [stdout] 784 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |       ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:801:21
[INFO] [stdout]     |
[INFO] [stdout] 801 | /                     bail_runtime_error!(
[INFO] [stdout] 802 | |                         "Invalid value '{value}' for array option '{name}', allowed values are: {choices:?}"
[INFO] [stdout] 803 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:91:13
[INFO] [stdout]    |
[INFO] [stdout] 91 |             bail_type_error!("has_argument requires a string argument");
[INFO] [stdout]    |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:97:17
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 bail_type_error!("The 'required' keyword argument must be a boolean");
[INFO] [stdout]    |                 --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:143:13
[INFO] [stdout]     |
[INFO] [stdout] 143 |             bail_type_error!("has_function requires a string argument");
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |             bail_type_error!("has_link_argument requires a string argument");
[INFO] [stdout]     |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:222:13
[INFO] [stdout]     |
[INFO] [stdout] 222 |             bail_type_error!("compiles requires a string argument");
[INFO] [stdout]     |             ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:241:13
[INFO] [stdout]     |
[INFO] [stdout] 241 |             bail_type_error!("links requires a string argument");
[INFO] [stdout]     |             ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/config_data.rs:95:17
[INFO] [stdout]    |
[INFO] [stdout] 95 |                 bail_type_error!("Expected int or bool as the second argument");
[INFO] [stdout]    |                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:118:13
[INFO] [stdout]     |
[INFO] [stdout] 118 |             bail_type_error!("merge_from requires a ConfigData object or a dict");
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:235:18
[INFO] [stdout]     |
[INFO] [stdout] 235 |             v => bail_type_error!("Unsupported value type for key {key}: {v:?}"),
[INFO] [stdout]     |                  --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/files.rs:47:17
[INFO] [stdout]    |
[INFO] [stdout] 47 |                 bail_type_error!("Expected arguments to be strings or File objects, got {arg:?}")
[INFO] [stdout]    |                 --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/import.rs:17:9
[INFO] [stdout]    |
[INFO] [stdout] 17 |         bail_type_error!("import requires a string argument");
[INFO] [stdout]    |         ----------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/option.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |         ty => bail_type_error!("Unsupported option type: {ty}"),
[INFO] [stdout]     |               ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/option.rs:143:17
[INFO] [stdout]     |
[INFO] [stdout] 143 |         None => bail_type_error!("No such option: {opt}"),
[INFO] [stdout]     |                 ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:14:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter.rs:93:18
[INFO] [stdout]    |
[INFO] [stdout] 93 |             _ => bail_type_error!("Expected a boolean, found {:?}", self),
[INFO] [stdout]    |                  -------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:100:18
[INFO] [stdout]     |
[INFO] [stdout] 100 |             _ => bail_type_error!("Expected a string, found {:?}", self),
[INFO] [stdout]     |                  ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:107:18
[INFO] [stdout]     |
[INFO] [stdout] 107 |             _ => bail_type_error!("Expected an array, found {:?}", self),
[INFO] [stdout]     |                  ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:114:18
[INFO] [stdout]     |
[INFO] [stdout] 114 |             _ => bail_type_error!("Expected an integer, found {:?}", self),
[INFO] [stdout]     |                  --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:134:18
[INFO] [stdout]     |
[INFO] [stdout] 134 |             _ => bail_type_error!("Expected a dict, found {:?}", self),
[INFO] [stdout]     |                  ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:385:25
[INFO] [stdout]     |
[INFO] [stdout] 385 |                         bail_type_error!("Cannot iterate over non-iterable");
[INFO] [stdout]     |                         ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:564:18
[INFO] [stdout]     |
[INFO] [stdout] 564 |             _ => bail_type_error!("Cannot call method '{method}' on {object:?}"),
[INFO] [stdout]     |                  --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:578:22
[INFO] [stdout]     |
[INFO] [stdout] 578 |                 _ => bail_type_error!("Cannot subtract non-integers"),
[INFO] [stdout]     |                      ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:585:22
[INFO] [stdout]     |
[INFO] [stdout] 585 |                 _ => bail_type_error!("Invalid operands for multiplication"),
[INFO] [stdout]     |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:601:26
[INFO] [stdout]     |
[INFO] [stdout] 601 |                     _ => bail_type_error!("Invalid operands for division"),
[INFO] [stdout]     |                          ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:612:22
[INFO] [stdout]     |
[INFO] [stdout] 612 |                 _ => bail_type_error!("Cannot modulo non-integers"),
[INFO] [stdout]     |                      ---------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:619:22
[INFO] [stdout]     |
[INFO] [stdout] 619 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:624:22
[INFO] [stdout]     |
[INFO] [stdout] 624 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:629:22
[INFO] [stdout]     |
[INFO] [stdout] 629 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:634:22
[INFO] [stdout]     |
[INFO] [stdout] 634 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:686:22
[INFO] [stdout]     |
[INFO] [stdout] 686 |                 _ => bail_type_error!("Cannot negate non-integer"),
[INFO] [stdout]     |                      --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:703:21
[INFO] [stdout]     |
[INFO] [stdout] 703 |                     bail_type_error!("Array index must be integer")
[INFO] [stdout]     |                     ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:712:21
[INFO] [stdout]     |
[INFO] [stdout] 712 |                     bail_type_error!("Dictionary key must be string")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:728:21
[INFO] [stdout]     |
[INFO] [stdout] 728 |                     bail_type_error!("String index must be integer")
[INFO] [stdout]     |                     ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:731:18
[INFO] [stdout]     |
[INFO] [stdout] 731 |             _ => bail_type_error!("Cannot subscript this type"),
[INFO] [stdout]     |                  ---------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:749:18
[INFO] [stdout]     |
[INFO] [stdout] 749 |             _ => bail_type_error!("Cannot add incompatible types {left:?} + {right:?}"),
[INFO] [stdout]     |                  ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `picomeson` (lib test) due to 59 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/build_target.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 73 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::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: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/build_target.rs:77:5
[INFO] [stdout]    |
[INFO] [stdout] 77 |       builtin_impl!(extract_objects, extract_all_objects, full_path);
[INFO] [stdout]    |       -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:27:5
[INFO] [stdout]    |
[INFO] [stdout] 27 | /     builtin_impl!(
[INFO] [stdout] 28 | |         get_id,
[INFO] [stdout] 29 | |         get_linker_id,
[INFO] [stdout] 30 | |         cmd_array,
[INFO] [stdout] ...  |
[INFO] [stdout] 38 | |         links,
[INFO] [stdout] 39 | |     );
[INFO] [stdout]    | |_____- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:107:13
[INFO] [stdout]     |
[INFO] [stdout] 107 |             bail_runtime_error!("Compiler does not support argument: {argument}");
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:21:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | macro_rules! bail_runtime_error {
[INFO] [stdout] 20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/config_data.rs:35:21
[INFO] [stdout]    |
[INFO] [stdout] 35 |             None => bail_runtime_error!("Key '{key}' not found in ConfigData"),
[INFO] [stdout]    |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | / macro_rules! bail_runtime_error {
[INFO] [stdout]  20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]  22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout]  23 | | }
[INFO] [stdout]     | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:125:5
[INFO] [stdout]     |
[INFO] [stdout] 125 |       builtin_impl!(get, set, set10, merge_from);
[INFO] [stdout]     |       ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:272:13
[INFO] [stdout]     |
[INFO] [stdout] 272 | /             bail_runtime_error!(
[INFO] [stdout] 273 | |                 "configure_file: The following placeholders were not replaced: {}",
[INFO] [stdout] 274 | |                 unreplaced.join(", ")
[INFO] [stdout] 275 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/env.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |       builtin_impl!(prepend);
[INFO] [stdout]    |       ---------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/external_program.rs:41:5
[INFO] [stdout]    |
[INFO] [stdout] 41 |       builtin_impl!(found, full_path);
[INFO] [stdout]    |       ------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/files.rs:24:5
[INFO] [stdout]    |
[INFO] [stdout] 24 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/filesystem.rs:15:5
[INFO] [stdout]    |
[INFO] [stdout] 15 |       builtin_impl!(replace_suffix, exists, is_file, is_dir);
[INFO] [stdout]    |       ------------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:21:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | macro_rules! bail_runtime_error {
[INFO] [stdout] 20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/import.rs:22:14
[INFO] [stdout]    |
[INFO] [stdout] 22 |         _ => bail_runtime_error!("No module named '{module_name}'"),
[INFO] [stdout]    |              ------------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/include_directories.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |       builtin_impl!();
[INFO] [stdout]    |       --------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/machine.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 |       builtin_impl!(system, cpu_family, cpu, endian);
[INFO] [stdout]    |       ---------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/meson.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 | /     builtin_impl!(
[INFO] [stdout] 21 | |         version,
[INFO] [stdout] 22 | |         is_subproject,
[INFO] [stdout] 23 | |         get_compiler,
[INFO] [stdout] ...  |
[INFO] [stdout] 28 | |         current_source_dir
[INFO] [stdout] 29 | |     );
[INFO] [stdout]    | |_____- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/run_result.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 |       builtin_impl!(stdout, stderr, returncode);
[INFO] [stdout]    |       ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:20:77
[INFO] [stdout]    |
[INFO] [stdout] 19 | / macro_rules! bail_runtime_error {
[INFO] [stdout] 20 | |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    | |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 21 | |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout] 22 | |     () =>                       { return Err(InterpreterError::RuntimeError("Runtime error".into())) };
[INFO] [stdout] 23 | | }
[INFO] [stdout]    | |_- this error originates in the macro `crate::interpreter::bail_runtime_error` which comes from the expansion of the macro `builtin_impl`
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/version.rs:37:5
[INFO] [stdout]    |
[INFO] [stdout] 37 |       builtin_impl!(version_compare);
[INFO] [stdout]    |       ------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:545:22
[INFO] [stdout]     |
[INFO] [stdout] 545 |                 _ => bail_runtime_error!("Unknown method '{method}' for string"),
[INFO] [stdout]     |                      ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:551:22
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 _ => bail_runtime_error!("Unknown method '{method}' for array"),
[INFO] [stdout]     |                      ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:558:22
[INFO] [stdout]     |
[INFO] [stdout] 558 |                 _ => bail_runtime_error!("Unknown method '{method}' for dict"),
[INFO] [stdout]     |                      --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:591:29
[INFO] [stdout]     |
[INFO] [stdout] 591 | ...                   bail_runtime_error!("Division by zero");
[INFO] [stdout]     |                       --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 | macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |     ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:607:25
[INFO] [stdout]     |
[INFO] [stdout] 607 |                         bail_runtime_error!("Modulo by zero");
[INFO] [stdout]     |                         ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:20:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:759:13
[INFO] [stdout]     |
[INFO] [stdout] 759 | /             bail_runtime_error!(
[INFO] [stdout] 760 | |                 "Option '{name}' is not defined. Available options: {:?}",
[INFO] [stdout] 761 | |                 self.options.keys().collect::<Vec<_>>()
[INFO] [stdout] 762 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |       ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:782:21
[INFO] [stdout]     |
[INFO] [stdout] 782 | /                     bail_runtime_error!(
[INFO] [stdout] 783 | |                         "Invalid value '{value}' for string option '{name}', allowed values are: {choices:?}"
[INFO] [stdout] 784 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:21:77
[INFO] [stdout]     |
[INFO] [stdout]  19 |   macro_rules! bail_runtime_error {
[INFO] [stdout]  20 |       ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::RuntimeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  21 |       ($msg:expr) =>              { return Err(InterpreterError::RuntimeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:801:21
[INFO] [stdout]     |
[INFO] [stdout] 801 | /                     bail_runtime_error!(
[INFO] [stdout] 802 | |                         "Invalid value '{value}' for array option '{name}', allowed values are: {choices:?}"
[INFO] [stdout] 803 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:91:13
[INFO] [stdout]    |
[INFO] [stdout] 91 |             bail_type_error!("has_argument requires a string argument");
[INFO] [stdout]    |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/compiler.rs:97:17
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 bail_type_error!("The 'required' keyword argument must be a boolean");
[INFO] [stdout]    |                 --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:143:13
[INFO] [stdout]     |
[INFO] [stdout] 143 |             bail_type_error!("has_function requires a string argument");
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |             bail_type_error!("has_link_argument requires a string argument");
[INFO] [stdout]     |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:222:13
[INFO] [stdout]     |
[INFO] [stdout] 222 |             bail_type_error!("compiles requires a string argument");
[INFO] [stdout]     |             ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/compiler.rs:241:13
[INFO] [stdout]     |
[INFO] [stdout] 241 |             bail_type_error!("links requires a string argument");
[INFO] [stdout]     |             ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/config_data.rs:95:17
[INFO] [stdout]    |
[INFO] [stdout] 95 |                 bail_type_error!("Expected int or bool as the second argument");
[INFO] [stdout]    |                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:118:13
[INFO] [stdout]     |
[INFO] [stdout] 118 |             bail_type_error!("merge_from requires a ConfigData object or a dict");
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/config_data.rs:235:18
[INFO] [stdout]     |
[INFO] [stdout] 235 |             v => bail_type_error!("Unsupported value type for key {key}: {v:?}"),
[INFO] [stdout]     |                  --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/files.rs:47:17
[INFO] [stdout]    |
[INFO] [stdout] 47 |                 bail_type_error!("Expected arguments to be strings or File objects, got {arg:?}")
[INFO] [stdout]    |                 --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:15:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout] 15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter/builtins/import.rs:17:9
[INFO] [stdout]    |
[INFO] [stdout] 17 |         bail_type_error!("import requires a string argument");
[INFO] [stdout]    |         ----------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/option.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |         ty => bail_type_error!("Unsupported option type: {ty}"),
[INFO] [stdout]     |               ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter/builtins/option.rs:143:17
[INFO] [stdout]     |
[INFO] [stdout] 143 |         None => bail_type_error!("No such option: {opt}"),
[INFO] [stdout]     |                 ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/interpreter/error.rs:14:74
[INFO] [stdout]    |
[INFO] [stdout] 13 | macro_rules! bail_type_error {
[INFO] [stdout] 14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/interpreter.rs:93:18
[INFO] [stdout]    |
[INFO] [stdout] 93 |             _ => bail_type_error!("Expected a boolean, found {:?}", self),
[INFO] [stdout]    |                  -------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:100:18
[INFO] [stdout]     |
[INFO] [stdout] 100 |             _ => bail_type_error!("Expected a string, found {:?}", self),
[INFO] [stdout]     |                  ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:107:18
[INFO] [stdout]     |
[INFO] [stdout] 107 |             _ => bail_type_error!("Expected an array, found {:?}", self),
[INFO] [stdout]     |                  ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:114:18
[INFO] [stdout]     |
[INFO] [stdout] 114 |             _ => bail_type_error!("Expected an integer, found {:?}", self),
[INFO] [stdout]     |                  --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:14:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:134:18
[INFO] [stdout]     |
[INFO] [stdout] 134 |             _ => bail_type_error!("Expected a dict, found {:?}", self),
[INFO] [stdout]     |                  ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:385:25
[INFO] [stdout]     |
[INFO] [stdout] 385 |                         bail_type_error!("Cannot iterate over non-iterable");
[INFO] [stdout]     |                         ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:564:18
[INFO] [stdout]     |
[INFO] [stdout] 564 |             _ => bail_type_error!("Cannot call method '{method}' on {object:?}"),
[INFO] [stdout]     |                  --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:578:22
[INFO] [stdout]     |
[INFO] [stdout] 578 |                 _ => bail_type_error!("Cannot subtract non-integers"),
[INFO] [stdout]     |                      ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:585:22
[INFO] [stdout]     |
[INFO] [stdout] 585 |                 _ => bail_type_error!("Invalid operands for multiplication"),
[INFO] [stdout]     |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:601:26
[INFO] [stdout]     |
[INFO] [stdout] 601 |                     _ => bail_type_error!("Invalid operands for division"),
[INFO] [stdout]     |                          ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:612:22
[INFO] [stdout]     |
[INFO] [stdout] 612 |                 _ => bail_type_error!("Cannot modulo non-integers"),
[INFO] [stdout]     |                      ---------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:619:22
[INFO] [stdout]     |
[INFO] [stdout] 619 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:624:22
[INFO] [stdout]     |
[INFO] [stdout] 624 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:629:22
[INFO] [stdout]     |
[INFO] [stdout] 629 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:634:22
[INFO] [stdout]     |
[INFO] [stdout] 634 |                 _ => bail_type_error!("Cannot compare incompatible types"),
[INFO] [stdout]     |                      ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:686:22
[INFO] [stdout]     |
[INFO] [stdout] 686 |                 _ => bail_type_error!("Cannot negate non-integer"),
[INFO] [stdout]     |                      --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:703:21
[INFO] [stdout]     |
[INFO] [stdout] 703 |                     bail_type_error!("Array index must be integer")
[INFO] [stdout]     |                     ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:712:21
[INFO] [stdout]     |
[INFO] [stdout] 712 |                     bail_type_error!("Dictionary key must be string")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:728:21
[INFO] [stdout]     |
[INFO] [stdout] 728 |                     bail_type_error!("String index must be integer")
[INFO] [stdout]     |                     ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:731:18
[INFO] [stdout]     |
[INFO] [stdout] 731 |             _ => bail_type_error!("Cannot subscript this type"),
[INFO] [stdout]     |                  ---------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/interpreter/error.rs:15:74
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_type_error {
[INFO] [stdout]  14 |     ($msg:expr, $($arg:tt)*) => { return Err(InterpreterError::TypeError(alloc::format!($msg, $($arg)*).into())) };
[INFO] [stdout]  15 |     ($msg:expr) =>              { return Err(InterpreterError::TypeError(alloc::format!($msg).into())) };
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:749:18
[INFO] [stdout]     |
[INFO] [stdout] 749 |             _ => bail_type_error!("Cannot add incompatible types {left:?} + {right:?}"),
[INFO] [stdout]     |                  ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `picomeson` (lib) due to 59 previous errors
[INFO] running `Command { std: "docker" "inspect" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d", kill_on_drop: false }`
[INFO] [stdout] b48e5f837abd34ee2d2e099bd3f3c04203f413b77b1fa1b910757668c28d0a0d
