[INFO] cloning repository https://github.com/busyst/rcsharp
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/busyst/rcsharp" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fbusyst%2Frcsharp", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fbusyst%2Frcsharp'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] e1f66ffd6be757252dc57eb39e39af748372df03
[INFO] checking busyst/rcsharp against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fbusyst%2Frcsharp" "/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/busyst/rcsharp
[INFO] finished tweaking git repo https://github.com/busyst/rcsharp
[INFO] tweaked toml for git repo https://github.com/busyst/rcsharp written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/busyst/rcsharp on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/busyst/rcsharp 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" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[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:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456
[INFO] running `Command { std: "docker" "start" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456", 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" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456", 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" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.106
[INFO] [stderr]    Compiling quote v1.0.45
[INFO] [stderr]    Compiling siphasher v1.0.2
[INFO] [stderr]    Compiling fastrand v2.3.0
[INFO] [stderr]     Checking utf8parse v0.2.2
[INFO] [stderr]     Checking memchr v2.8.0
[INFO] [stderr]     Checking anstyle-query v1.1.5
[INFO] [stderr]     Checking colorchoice v1.0.5
[INFO] [stderr]     Checking anstyle-parse v1.0.0
[INFO] [stderr]     Checking is_terminal_polyfill v1.70.2
[INFO] [stderr]     Checking anstyle v1.0.14
[INFO] [stderr]     Checking phf_shared v0.13.1
[INFO] [stderr]     Checking clap_lex v1.1.0
[INFO] [stderr]     Checking strsim v0.11.1
[INFO] [stderr]    Compiling heck v0.5.0
[INFO] [stderr]     Checking regex-syntax v0.8.9
[INFO] [stderr]     Checking ordered_hash_map v0.5.0
[INFO] [stderr]     Checking anstream v1.0.0
[INFO] [stderr]     Checking clap_builder v4.6.0
[INFO] [stderr]    Compiling phf_generator v0.13.1
[INFO] [stderr]     Checking aho-corasick v1.1.4
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking regex-automata v0.4.14
[INFO] [stderr]     Checking regex v1.12.3
[INFO] [stderr]    Compiling phf_macros v0.13.1
[INFO] [stderr]    Compiling clap_derive v4.6.1
[INFO] [stderr]     Checking phf v0.13.1
[INFO] [stderr]     Checking rcsharp_lexer v1.0.0 (/opt/rustwide/workdir/rcsharp_lexer)
[INFO] [stderr]     Checking rcsharp_parser v1.0.0 (/opt/rustwide/workdir/rcsharp_parser)
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]     Checking rcsharp v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:761:24
[INFO] [stdout]     |
[INFO] [stdout] 761 |               return Err(CompilerError::Generic(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout] 762 | |                 "Left side of binary operation is not value".into(),
[INFO] [stdout] 763 | |             )
[INFO] [stdout] 764 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 763 -             )
[INFO] [stdout] 764 -             .into());
[INFO] [stdout] 763 +             ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 ~             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 762 |                 "Left side of binary operation is not value".into(),
[INFO] [stdout] 763 ~             )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:767:24
[INFO] [stdout]     |
[INFO] [stdout] 767 |             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 767 -             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout] 767 +             return Err(CompilerError::Generic(format!("Not Boolean")));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 767 -             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout] 767 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Not Boolean"))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:801:24
[INFO] [stdout]     |
[INFO] [stdout] 801 |               return Err(CompilerError::Generic(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout] 802 | |                 "Right side of binary operation is not value".into(),
[INFO] [stdout] 803 | |             )
[INFO] [stdout] 804 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 803 -             )
[INFO] [stdout] 804 -             .into());
[INFO] [stdout] 803 +             ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 801 ~             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 802 |                 "Right side of binary operation is not value".into(),
[INFO] [stdout] 803 ~             )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:807:24
[INFO] [stdout]     |
[INFO] [stdout] 807 |             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 807 -             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout] 807 +             return Err(CompilerError::Generic(format!("Not boolean")));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 807 -             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout] 807 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Not boolean"))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1333:24
[INFO] [stdout]      |
[INFO] [stdout] 1333 |             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1333 -             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout] 1333 +             return Err(CompilerError::Generic("Argument is not a value".into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1333 -             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout] 1333 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("Argument is not a value".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1348:24
[INFO] [stdout]      |
[INFO] [stdout] 1348 |             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1348 -             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout] 1348 +             return Err(CompilerError::Generic("Casting value is not a type".into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1348 -             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout] 1348 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("Casting value is not a type".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1492:20
[INFO] [stdout]      |
[INFO] [stdout] 1492 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  ____________________^
[INFO] [stdout] 1493 | |             "Cannot explicitly cast {:?} to {:?}",
[INFO] [stdout] 1494 | |             value_type, to_type
[INFO] [stdout] 1495 | |         ))
[INFO] [stdout] 1496 | |         .into());
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1495 -         ))
[INFO] [stdout] 1496 -         .into());
[INFO] [stdout] 1495 +         )));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1492 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1493 |             "Cannot explicitly cast {:?} to {:?}",
[INFO] [stdout] 1494 |             value_type, to_type
[INFO] [stdout] 1495 ~         ))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1596:32
[INFO] [stdout]      |
[INFO] [stdout] 1596 |                       return Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  ________________________________^
[INFO] [stdout] 1597 | |                         "Generic function '{}' requires generic parameters",
[INFO] [stdout] 1598 | |                         internal_id
[INFO] [stdout] 1599 | |                     ))
[INFO] [stdout] 1600 | |                     .into());
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1599 -                     ))
[INFO] [stdout] 1600 -                     .into());
[INFO] [stdout] 1599 +                     )));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1596 ~                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1597 |                         "Generic function '{}' requires generic parameters",
[INFO] [stdout] 1598 |                         internal_id
[INFO] [stdout] 1599 ~                     ))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1605:32
[INFO] [stdout]      |
[INFO] [stdout] 1605 |                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout] 1605 +                     return Err(CompilerError::Generic(format!("Function is not generic")));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout] 1605 +                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Function is not generic"))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1633:13
[INFO] [stdout]      |
[INFO] [stdout] 1633 |           Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  _____________^
[INFO] [stdout] 1634 | |             "Lvalue with generics '{:?}' is not a generic function",
[INFO] [stdout] 1635 | |             name
[INFO] [stdout] 1636 | |         ))
[INFO] [stdout] 1637 | |         .into())
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1636 -         ))
[INFO] [stdout] 1637 -         .into())
[INFO] [stdout] 1636 +         )))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1633 ~         Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1634 |             "Lvalue with generics '{:?}' is not a generic function",
[INFO] [stdout] 1635 |             name
[INFO] [stdout] 1636 ~         ))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1791:28
[INFO] [stdout]      |
[INFO] [stdout] 1791 |                   return Err(CompilerError::Generic(
[INFO] [stdout]      |  ____________________________^
[INFO] [stdout] 1792 | |                     "Object in member access is not a value".into(),
[INFO] [stdout] 1793 | |                 )
[INFO] [stdout] 1794 | |                 .into());
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1793 -                 )
[INFO] [stdout] 1794 -                 .into());
[INFO] [stdout] 1793 +                 ));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1791 ~                 return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 1792 |                     "Object in member access is not a value".into(),
[INFO] [stdout] 1793 ~                 )));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/compiler/passes/pass_type_check.rs:122:21
[INFO] [stdout]     |
[INFO] [stdout] 122 | /                     format!(
[INFO] [stdout] 123 | |                         "Enum '{}' must have an integer backing type",
[INFO] [stdout] 124 | |                         parsed_enum.name
[INFO] [stdout] 125 | |                     )
[INFO] [stdout] 126 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/structs.rs:349:22
[INFO] [stdout]     |
[INFO] [stdout] 349 |               _ => Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 350 | |                 "Value {:?} has no LLVM representation",
[INFO] [stdout] 351 | |                 self
[INFO] [stdout] 352 | |             ))
[INFO] [stdout] 353 | |             .into()),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -             ))
[INFO] [stdout] 353 -             .into()),
[INFO] [stdout] 352 +             ))),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 ~             _ => Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 350 |                 "Value {:?} has no LLVM representation",
[INFO] [stdout] 351 |                 self
[INFO] [stdout] 352 ~             )))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_essentials.rs:183:22
[INFO] [stdout]     |
[INFO] [stdout] 183 |             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 183 -             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout] 183 +             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self))),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 -             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout] 183 +             _ => Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_essentials.rs:398:32
[INFO] [stdout]     |
[INFO] [stdout] 398 |                       return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout] 399 | |                         "Generic placeholder {} not found in substitution map",
[INFO] [stdout] 400 | |                         name,
[INFO] [stdout] 401 | |                     ))
[INFO] [stdout] 402 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -                     ))
[INFO] [stdout] 402 -                     .into());
[INFO] [stdout] 401 +                     )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 398 ~                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 399 |                         "Generic placeholder {} not found in substitution map",
[INFO] [stdout] 400 |                         name,
[INFO] [stdout] 401 ~                     ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:71:20
[INFO] [stdout]    |
[INFO] [stdout] 71 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]    |  ____________________^
[INFO] [stdout] 72 | |             "stalloc(count) expects exactly 1 argument, but got {}",
[INFO] [stdout] 73 | |             given_args.len()
[INFO] [stdout] 74 | |         ))
[INFO] [stdout] 75 | |         .into());
[INFO] [stdout]    | |_______________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -         ))
[INFO] [stdout] 75 -         .into());
[INFO] [stdout] 74 +         )));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 72 |             "stalloc(count) expects exactly 1 argument, but got {}",
[INFO] [stdout] 73 |             given_args.len()
[INFO] [stdout] 74 ~         ))));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:82:20
[INFO] [stdout]    |
[INFO] [stdout] 82 |         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 82 -         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout] 82 +         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 -         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout] 82 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("stalloc(arg) arg is not a value".into())));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:85:20
[INFO] [stdout]    |
[INFO] [stdout] 85 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]    |  ____________________^
[INFO] [stdout] 86 | |             "stalloc(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 87 | |             count_type
[INFO] [stdout] 88 | |         ))
[INFO] [stdout] 89 | |         .into());
[INFO] [stdout]    | |_______________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 88 -         ))
[INFO] [stdout] 89 -         .into());
[INFO] [stdout] 88 +         )));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 86 |             "stalloc(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 87 |             count_type
[INFO] [stdout] 88 ~         ))));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:114:20
[INFO] [stdout]     |
[INFO] [stdout] 114 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 115 | |             "stalloc<T>(arg) expects exactly 1 generic type, but got {}",
[INFO] [stdout] 116 | |             given_generic.len()
[INFO] [stdout] 117 | |         ))
[INFO] [stdout] 118 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 117 -         ))
[INFO] [stdout] 118 -         .into());
[INFO] [stdout] 117 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 115 |             "stalloc<T>(arg) expects exactly 1 generic type, but got {}",
[INFO] [stdout] 116 |             given_generic.len()
[INFO] [stdout] 117 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:121:20
[INFO] [stdout]     |
[INFO] [stdout] 121 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 122 | |             "stalloc<T>(arg) expects exactly 1 argument (arg), but got {}",
[INFO] [stdout] 123 | |             given_args.len()
[INFO] [stdout] 124 | |         ))
[INFO] [stdout] 125 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 124 -         ))
[INFO] [stdout] 125 -         .into());
[INFO] [stdout] 124 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 122 |             "stalloc<T>(arg) expects exactly 1 argument (arg), but got {}",
[INFO] [stdout] 123 |             given_args.len()
[INFO] [stdout] 124 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:131:20
[INFO] [stdout]     |
[INFO] [stdout] 131 |         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout] 131 +         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout] 131 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:134:20
[INFO] [stdout]     |
[INFO] [stdout] 134 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 135 | |             "stalloc<T>(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 136 | |             count_type
[INFO] [stdout] 137 | |         ))
[INFO] [stdout] 138 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -         ))
[INFO] [stdout] 138 -         .into());
[INFO] [stdout] 137 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 135 |             "stalloc<T>(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 136 |             count_type
[INFO] [stdout] 137 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:165:20
[INFO] [stdout]     |
[INFO] [stdout] 165 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 166 | |             "size_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 167 | |             given_args.len()
[INFO] [stdout] 168 | |         ))
[INFO] [stdout] 169 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 168 -         ))
[INFO] [stdout] 169 -         .into());
[INFO] [stdout] 168 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 166 |             "size_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 167 |             given_args.len()
[INFO] [stdout] 168 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:173:20
[INFO] [stdout]     |
[INFO] [stdout] 173 |         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 173 -         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout] 173 +         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 -         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout] 173 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("size_of(Type) Type is not a type".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:195:20
[INFO] [stdout]     |
[INFO] [stdout] 195 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 196 | |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 197 | |             given_generic.len()
[INFO] [stdout] 198 | |         ))
[INFO] [stdout] 199 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -         ))
[INFO] [stdout] 199 -         .into());
[INFO] [stdout] 198 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 196 |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 197 |             given_generic.len()
[INFO] [stdout] 198 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:202:20
[INFO] [stdout]     |
[INFO] [stdout] 202 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 203 | |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 204 | |             given_args.len()
[INFO] [stdout] 205 | |         ))
[INFO] [stdout] 206 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         ))
[INFO] [stdout] 206 -         .into());
[INFO] [stdout] 205 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 203 |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 204 |             given_args.len()
[INFO] [stdout] 205 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:234:20
[INFO] [stdout]     |
[INFO] [stdout] 234 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 235 | |             "ptr_of(variable) expects exactly 1 argument, but got {}",
[INFO] [stdout] 236 | |             given_args.len()
[INFO] [stdout] 237 | |         ))
[INFO] [stdout] 238 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -         ))
[INFO] [stdout] 238 -         .into());
[INFO] [stdout] 237 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 235 |             "ptr_of(variable) expects exactly 1 argument, but got {}",
[INFO] [stdout] 236 |             given_args.len()
[INFO] [stdout] 237 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:277:20
[INFO] [stdout]     |
[INFO] [stdout] 277 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 278 | |             "align_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 279 | |             given_args.len()
[INFO] [stdout] 280 | |         ))
[INFO] [stdout] 281 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 280 -         ))
[INFO] [stdout] 281 -         .into());
[INFO] [stdout] 280 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 278 |             "align_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 279 |             given_args.len()
[INFO] [stdout] 280 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:285:20
[INFO] [stdout]     |
[INFO] [stdout] 285 |         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout] 285 +         return Err(CompilerError::Generic("align_of(Type) is not a type".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout] 285 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("align_of(Type) is not a type".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:308:20
[INFO] [stdout]     |
[INFO] [stdout] 308 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 309 | |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 310 | |             given_generic.len()
[INFO] [stdout] 311 | |         ))
[INFO] [stdout] 312 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 311 -         ))
[INFO] [stdout] 312 -         .into());
[INFO] [stdout] 311 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 309 |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 310 |             given_generic.len()
[INFO] [stdout] 311 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:315:20
[INFO] [stdout]     |
[INFO] [stdout] 315 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 316 | |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 317 | |             given_args.len()
[INFO] [stdout] 318 | |         ))
[INFO] [stdout] 319 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -         ))
[INFO] [stdout] 319 -         .into());
[INFO] [stdout] 318 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 315 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 316 |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 317 |             given_args.len()
[INFO] [stdout] 318 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:348:20
[INFO] [stdout]     |
[INFO] [stdout] 348 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 349 | |             "{} needs exactly 1 generic argument, but got {}",
[INFO] [stdout] 350 | |             "bitcast<T>(value)",
[INFO] [stdout] 351 | |             given_generic.len(),
[INFO] [stdout] 352 | |         ))
[INFO] [stdout] 353 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -         ))
[INFO] [stdout] 353 -         .into());
[INFO] [stdout] 352 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 349 |             "{} needs exactly 1 generic argument, but got {}",
[INFO] [stdout] 350 |             "bitcast<T>(value)",
[INFO] [stdout] 351 |             given_generic.len(),
[INFO] [stdout] 352 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:356:20
[INFO] [stdout]     |
[INFO] [stdout] 356 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 357 | |             "{} needs exactly 1 argument, but got {}",
[INFO] [stdout] 358 | |             "bitcast<T>(value)",
[INFO] [stdout] 359 | |             given_args.len()
[INFO] [stdout] 360 | |         ))
[INFO] [stdout] 361 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -         ))
[INFO] [stdout] 361 -         .into());
[INFO] [stdout] 360 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 357 |             "{} needs exactly 1 argument, but got {}",
[INFO] [stdout] 358 |             "bitcast<T>(value)",
[INFO] [stdout] 359 |             given_args.len()
[INFO] [stdout] 360 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:371:20
[INFO] [stdout]     |
[INFO] [stdout] 371 |         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 371 -         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout] 371 +         return Err(CompilerError::Generic("bitcast source is not a value".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 371 -         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout] 371 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("bitcast source is not a value".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:392:20
[INFO] [stdout]     |
[INFO] [stdout] 392 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 393 | |             "bitcast size mismatch: cannot cast from {:?} to {:?}",
[INFO] [stdout] 394 | |             source_type, target_type
[INFO] [stdout] 395 | |         ))
[INFO] [stdout] 396 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 395 -         ))
[INFO] [stdout] 396 -         .into());
[INFO] [stdout] 395 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 392 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 393 |             "bitcast size mismatch: cannot cast from {:?} to {:?}",
[INFO] [stdout] 394 |             source_type, target_type
[INFO] [stdout] 395 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:493:20
[INFO] [stdout]     |
[INFO] [stdout] 493 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 494 | |             "asm_impl(variable) expects exactly 4 arguments, but got {}",
[INFO] [stdout] 495 | |             given_args.len()
[INFO] [stdout] 496 | |         ))
[INFO] [stdout] 497 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 496 -         ))
[INFO] [stdout] 497 -         .into());
[INFO] [stdout] 496 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 494 |             "asm_impl(variable) expects exactly 4 arguments, but got {}",
[INFO] [stdout] 495 |             given_args.len()
[INFO] [stdout] 496 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:500:20
[INFO] [stdout]     |
[INFO] [stdout] 500 |           return Err(CompilerError::Generic(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 501 | |             "asm() blocks currently do not support returning values directly. Use output operands."
[INFO] [stdout] 502 | |                 .into(),
[INFO] [stdout] 503 | |         )
[INFO] [stdout] 504 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -         )
[INFO] [stdout] 504 -         .into());
[INFO] [stdout] 503 +         ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 500 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 501 |             "asm() blocks currently do not support returning values directly. Use output operands."
[INFO] [stdout] 502 |                 .into(),
[INFO] [stdout] 503 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rcsharp` (bin "rcsharp") due to 37 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:761:24
[INFO] [stdout]     |
[INFO] [stdout] 761 |               return Err(CompilerError::Generic(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout] 762 | |                 "Left side of binary operation is not value".into(),
[INFO] [stdout] 763 | |             )
[INFO] [stdout] 764 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 763 -             )
[INFO] [stdout] 764 -             .into());
[INFO] [stdout] 763 +             ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 ~             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 762 |                 "Left side of binary operation is not value".into(),
[INFO] [stdout] 763 ~             )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:767:24
[INFO] [stdout]     |
[INFO] [stdout] 767 |             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 767 -             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout] 767 +             return Err(CompilerError::Generic(format!("Not Boolean")));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 767 -             return Err(CompilerError::Generic(format!("Not Boolean")).into());
[INFO] [stdout] 767 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Not Boolean"))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:801:24
[INFO] [stdout]     |
[INFO] [stdout] 801 |               return Err(CompilerError::Generic(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout] 802 | |                 "Right side of binary operation is not value".into(),
[INFO] [stdout] 803 | |             )
[INFO] [stdout] 804 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 803 -             )
[INFO] [stdout] 804 -             .into());
[INFO] [stdout] 803 +             ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 801 ~             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 802 |                 "Right side of binary operation is not value".into(),
[INFO] [stdout] 803 ~             )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/expression/mod.rs:807:24
[INFO] [stdout]     |
[INFO] [stdout] 807 |             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 807 -             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout] 807 +             return Err(CompilerError::Generic(format!("Not boolean")));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 807 -             return Err(CompilerError::Generic(format!("Not boolean")).into());
[INFO] [stdout] 807 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Not boolean"))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1333:24
[INFO] [stdout]      |
[INFO] [stdout] 1333 |             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1333 -             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout] 1333 +             return Err(CompilerError::Generic("Argument is not a value".into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1333 -             return Err(CompilerError::Generic("Argument is not a value".into()).into());
[INFO] [stdout] 1333 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("Argument is not a value".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1348:24
[INFO] [stdout]      |
[INFO] [stdout] 1348 |             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1348 -             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout] 1348 +             return Err(CompilerError::Generic("Casting value is not a type".into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1348 -             return Err(CompilerError::Generic("Casting value is not a type".into()).into());
[INFO] [stdout] 1348 +             return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("Casting value is not a type".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1492:20
[INFO] [stdout]      |
[INFO] [stdout] 1492 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  ____________________^
[INFO] [stdout] 1493 | |             "Cannot explicitly cast {:?} to {:?}",
[INFO] [stdout] 1494 | |             value_type, to_type
[INFO] [stdout] 1495 | |         ))
[INFO] [stdout] 1496 | |         .into());
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1495 -         ))
[INFO] [stdout] 1496 -         .into());
[INFO] [stdout] 1495 +         )));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1492 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1493 |             "Cannot explicitly cast {:?} to {:?}",
[INFO] [stdout] 1494 |             value_type, to_type
[INFO] [stdout] 1495 ~         ))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1596:32
[INFO] [stdout]      |
[INFO] [stdout] 1596 |                       return Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  ________________________________^
[INFO] [stdout] 1597 | |                         "Generic function '{}' requires generic parameters",
[INFO] [stdout] 1598 | |                         internal_id
[INFO] [stdout] 1599 | |                     ))
[INFO] [stdout] 1600 | |                     .into());
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1599 -                     ))
[INFO] [stdout] 1600 -                     .into());
[INFO] [stdout] 1599 +                     )));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1596 ~                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1597 |                         "Generic function '{}' requires generic parameters",
[INFO] [stdout] 1598 |                         internal_id
[INFO] [stdout] 1599 ~                     ))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1605:32
[INFO] [stdout]      |
[INFO] [stdout] 1605 |                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout] 1605 +                     return Err(CompilerError::Generic(format!("Function is not generic")));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1605 -                     return Err(CompilerError::Generic(format!("Function is not generic")).into());
[INFO] [stdout] 1605 +                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Function is not generic"))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1633:13
[INFO] [stdout]      |
[INFO] [stdout] 1633 |           Err(CompilerError::Generic(format!(
[INFO] [stdout]      |  _____________^
[INFO] [stdout] 1634 | |             "Lvalue with generics '{:?}' is not a generic function",
[INFO] [stdout] 1635 | |             name
[INFO] [stdout] 1636 | |         ))
[INFO] [stdout] 1637 | |         .into())
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1636 -         ))
[INFO] [stdout] 1637 -         .into())
[INFO] [stdout] 1636 +         )))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1633 ~         Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 1634 |             "Lvalue with generics '{:?}' is not a generic function",
[INFO] [stdout] 1635 |             name
[INFO] [stdout] 1636 ~         ))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]     --> src/compiler/expression/mod.rs:1791:28
[INFO] [stdout]      |
[INFO] [stdout] 1791 |                   return Err(CompilerError::Generic(
[INFO] [stdout]      |  ____________________________^
[INFO] [stdout] 1792 | |                     "Object in member access is not a value".into(),
[INFO] [stdout] 1793 | |                 )
[INFO] [stdout] 1794 | |                 .into());
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1793 -                 )
[INFO] [stdout] 1794 -                 .into());
[INFO] [stdout] 1793 +                 ));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1791 ~                 return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 1792 |                     "Object in member access is not a value".into(),
[INFO] [stdout] 1793 ~                 )));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/compiler/passes/pass_type_check.rs:122:21
[INFO] [stdout]     |
[INFO] [stdout] 122 | /                     format!(
[INFO] [stdout] 123 | |                         "Enum '{}' must have an integer backing type",
[INFO] [stdout] 124 | |                         parsed_enum.name
[INFO] [stdout] 125 | |                     )
[INFO] [stdout] 126 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler/structs.rs:349:22
[INFO] [stdout]     |
[INFO] [stdout] 349 |               _ => Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 350 | |                 "Value {:?} has no LLVM representation",
[INFO] [stdout] 351 | |                 self
[INFO] [stdout] 352 | |             ))
[INFO] [stdout] 353 | |             .into()),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -             ))
[INFO] [stdout] 353 -             .into()),
[INFO] [stdout] 352 +             ))),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 ~             _ => Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 350 |                 "Value {:?} has no LLVM representation",
[INFO] [stdout] 351 |                 self
[INFO] [stdout] 352 ~             )))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_essentials.rs:183:22
[INFO] [stdout]     |
[INFO] [stdout] 183 |             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 183 -             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout] 183 +             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self))),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 -             _ => Err(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)).into()),
[INFO] [stdout] 183 +             _ => Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!("Cannot get LLVM repr for {:?}", self)))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_essentials.rs:398:32
[INFO] [stdout]     |
[INFO] [stdout] 398 |                       return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout] 399 | |                         "Generic placeholder {} not found in substitution map",
[INFO] [stdout] 400 | |                         name,
[INFO] [stdout] 401 | |                     ))
[INFO] [stdout] 402 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -                     ))
[INFO] [stdout] 402 -                     .into());
[INFO] [stdout] 401 +                     )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 398 ~                     return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 399 |                         "Generic placeholder {} not found in substitution map",
[INFO] [stdout] 400 |                         name,
[INFO] [stdout] 401 ~                     ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:71:20
[INFO] [stdout]    |
[INFO] [stdout] 71 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]    |  ____________________^
[INFO] [stdout] 72 | |             "stalloc(count) expects exactly 1 argument, but got {}",
[INFO] [stdout] 73 | |             given_args.len()
[INFO] [stdout] 74 | |         ))
[INFO] [stdout] 75 | |         .into());
[INFO] [stdout]    | |_______________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -         ))
[INFO] [stdout] 75 -         .into());
[INFO] [stdout] 74 +         )));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 72 |             "stalloc(count) expects exactly 1 argument, but got {}",
[INFO] [stdout] 73 |             given_args.len()
[INFO] [stdout] 74 ~         ))));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:82:20
[INFO] [stdout]    |
[INFO] [stdout] 82 |         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 82 -         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout] 82 +         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 -         return Err(CompilerError::Generic("stalloc(arg) arg is not a value".into()).into());
[INFO] [stdout] 82 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("stalloc(arg) arg is not a value".into())));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]   --> src/compiler_functions.rs:85:20
[INFO] [stdout]    |
[INFO] [stdout] 85 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]    |  ____________________^
[INFO] [stdout] 86 | |             "stalloc(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 87 | |             count_type
[INFO] [stdout] 88 | |         ))
[INFO] [stdout] 89 | |         .into());
[INFO] [stdout]    | |_______________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 88 -         ))
[INFO] [stdout] 89 -         .into());
[INFO] [stdout] 88 +         )));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 86 |             "stalloc(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 87 |             count_type
[INFO] [stdout] 88 ~         ))));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:114:20
[INFO] [stdout]     |
[INFO] [stdout] 114 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 115 | |             "stalloc<T>(arg) expects exactly 1 generic type, but got {}",
[INFO] [stdout] 116 | |             given_generic.len()
[INFO] [stdout] 117 | |         ))
[INFO] [stdout] 118 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 117 -         ))
[INFO] [stdout] 118 -         .into());
[INFO] [stdout] 117 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 115 |             "stalloc<T>(arg) expects exactly 1 generic type, but got {}",
[INFO] [stdout] 116 |             given_generic.len()
[INFO] [stdout] 117 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:121:20
[INFO] [stdout]     |
[INFO] [stdout] 121 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 122 | |             "stalloc<T>(arg) expects exactly 1 argument (arg), but got {}",
[INFO] [stdout] 123 | |             given_args.len()
[INFO] [stdout] 124 | |         ))
[INFO] [stdout] 125 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 124 -         ))
[INFO] [stdout] 125 -         .into());
[INFO] [stdout] 124 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 122 |             "stalloc<T>(arg) expects exactly 1 argument (arg), but got {}",
[INFO] [stdout] 123 |             given_args.len()
[INFO] [stdout] 124 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:131:20
[INFO] [stdout]     |
[INFO] [stdout] 131 |         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout] 131 +         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -         return Err(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into()).into());
[INFO] [stdout] 131 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("stalloc<T>(arg) arg is not a value".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:134:20
[INFO] [stdout]     |
[INFO] [stdout] 134 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 135 | |             "stalloc<T>(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 136 | |             count_type
[INFO] [stdout] 137 | |         ))
[INFO] [stdout] 138 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -         ))
[INFO] [stdout] 138 -         .into());
[INFO] [stdout] 137 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 135 |             "stalloc<T>(arg); arg must be an integer, but got {:?}",
[INFO] [stdout] 136 |             count_type
[INFO] [stdout] 137 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:165:20
[INFO] [stdout]     |
[INFO] [stdout] 165 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 166 | |             "size_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 167 | |             given_args.len()
[INFO] [stdout] 168 | |         ))
[INFO] [stdout] 169 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 168 -         ))
[INFO] [stdout] 169 -         .into());
[INFO] [stdout] 168 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 166 |             "size_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 167 |             given_args.len()
[INFO] [stdout] 168 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:173:20
[INFO] [stdout]     |
[INFO] [stdout] 173 |         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 173 -         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout] 173 +         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 -         return Err(CompilerError::Generic("size_of(Type) Type is not a type".into()).into());
[INFO] [stdout] 173 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("size_of(Type) Type is not a type".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:195:20
[INFO] [stdout]     |
[INFO] [stdout] 195 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 196 | |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 197 | |             given_generic.len()
[INFO] [stdout] 198 | |         ))
[INFO] [stdout] 199 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -         ))
[INFO] [stdout] 199 -         .into());
[INFO] [stdout] 198 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 196 |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 197 |             given_generic.len()
[INFO] [stdout] 198 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:202:20
[INFO] [stdout]     |
[INFO] [stdout] 202 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 203 | |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 204 | |             given_args.len()
[INFO] [stdout] 205 | |         ))
[INFO] [stdout] 206 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         ))
[INFO] [stdout] 206 -         .into());
[INFO] [stdout] 205 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 203 |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 204 |             given_args.len()
[INFO] [stdout] 205 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:234:20
[INFO] [stdout]     |
[INFO] [stdout] 234 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 235 | |             "ptr_of(variable) expects exactly 1 argument, but got {}",
[INFO] [stdout] 236 | |             given_args.len()
[INFO] [stdout] 237 | |         ))
[INFO] [stdout] 238 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -         ))
[INFO] [stdout] 238 -         .into());
[INFO] [stdout] 237 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 235 |             "ptr_of(variable) expects exactly 1 argument, but got {}",
[INFO] [stdout] 236 |             given_args.len()
[INFO] [stdout] 237 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:277:20
[INFO] [stdout]     |
[INFO] [stdout] 277 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 278 | |             "align_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 279 | |             given_args.len()
[INFO] [stdout] 280 | |         ))
[INFO] [stdout] 281 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 280 -         ))
[INFO] [stdout] 281 -         .into());
[INFO] [stdout] 280 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 278 |             "align_of(Type) expects exactly 1 argument, but got {}",
[INFO] [stdout] 279 |             given_args.len()
[INFO] [stdout] 280 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:285:20
[INFO] [stdout]     |
[INFO] [stdout] 285 |         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout] 285 +         return Err(CompilerError::Generic("align_of(Type) is not a type".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -         return Err(CompilerError::Generic("align_of(Type) is not a type".into()).into());
[INFO] [stdout] 285 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("align_of(Type) is not a type".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:308:20
[INFO] [stdout]     |
[INFO] [stdout] 308 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 309 | |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 310 | |             given_generic.len()
[INFO] [stdout] 311 | |         ))
[INFO] [stdout] 312 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 311 -         ))
[INFO] [stdout] 312 -         .into());
[INFO] [stdout] 311 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 309 |             "size_of<T>() expects exactly 1 generic type, but got {}",
[INFO] [stdout] 310 |             given_generic.len()
[INFO] [stdout] 311 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:315:20
[INFO] [stdout]     |
[INFO] [stdout] 315 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 316 | |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 317 | |             given_args.len()
[INFO] [stdout] 318 | |         ))
[INFO] [stdout] 319 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -         ))
[INFO] [stdout] 319 -         .into());
[INFO] [stdout] 318 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 315 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 316 |             "size_of<T>() expects 0 arguments, but got {}",
[INFO] [stdout] 317 |             given_args.len()
[INFO] [stdout] 318 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:348:20
[INFO] [stdout]     |
[INFO] [stdout] 348 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 349 | |             "{} needs exactly 1 generic argument, but got {}",
[INFO] [stdout] 350 | |             "bitcast<T>(value)",
[INFO] [stdout] 351 | |             given_generic.len(),
[INFO] [stdout] 352 | |         ))
[INFO] [stdout] 353 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -         ))
[INFO] [stdout] 353 -         .into());
[INFO] [stdout] 352 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 349 |             "{} needs exactly 1 generic argument, but got {}",
[INFO] [stdout] 350 |             "bitcast<T>(value)",
[INFO] [stdout] 351 |             given_generic.len(),
[INFO] [stdout] 352 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:356:20
[INFO] [stdout]     |
[INFO] [stdout] 356 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 357 | |             "{} needs exactly 1 argument, but got {}",
[INFO] [stdout] 358 | |             "bitcast<T>(value)",
[INFO] [stdout] 359 | |             given_args.len()
[INFO] [stdout] 360 | |         ))
[INFO] [stdout] 361 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -         ))
[INFO] [stdout] 361 -         .into());
[INFO] [stdout] 360 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 357 |             "{} needs exactly 1 argument, but got {}",
[INFO] [stdout] 358 |             "bitcast<T>(value)",
[INFO] [stdout] 359 |             given_args.len()
[INFO] [stdout] 360 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:371:20
[INFO] [stdout]     |
[INFO] [stdout] 371 |         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 371 -         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout] 371 +         return Err(CompilerError::Generic("bitcast source is not a value".into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 371 -         return Err(CompilerError::Generic("bitcast source is not a value".into()).into());
[INFO] [stdout] 371 +         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic("bitcast source is not a value".into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:392:20
[INFO] [stdout]     |
[INFO] [stdout] 392 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 393 | |             "bitcast size mismatch: cannot cast from {:?} to {:?}",
[INFO] [stdout] 394 | |             source_type, target_type
[INFO] [stdout] 395 | |         ))
[INFO] [stdout] 396 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 395 -         ))
[INFO] [stdout] 396 -         .into());
[INFO] [stdout] 395 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 392 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 393 |             "bitcast size mismatch: cannot cast from {:?} to {:?}",
[INFO] [stdout] 394 |             source_type, target_type
[INFO] [stdout] 395 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:493:20
[INFO] [stdout]     |
[INFO] [stdout] 493 |           return Err(CompilerError::Generic(format!(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 494 | |             "asm_impl(variable) expects exactly 4 arguments, but got {}",
[INFO] [stdout] 495 | |             given_args.len()
[INFO] [stdout] 496 | |         ))
[INFO] [stdout] 497 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 496 -         ))
[INFO] [stdout] 497 -         .into());
[INFO] [stdout] 496 +         )));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(format!(
[INFO] [stdout] 494 |             "asm_impl(variable) expects exactly 4 arguments, but got {}",
[INFO] [stdout] 495 |             given_args.len()
[INFO] [stdout] 496 ~         ))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CompilerError`
[INFO] [stdout]    --> src/compiler_functions.rs:500:20
[INFO] [stdout]     |
[INFO] [stdout] 500 |           return Err(CompilerError::Generic(
[INFO] [stdout]     |  ____________________^
[INFO] [stdout] 501 | |             "asm() blocks currently do not support returning values directly. Use output operands."
[INFO] [stdout] 502 | |                 .into(),
[INFO] [stdout] 503 | |         )
[INFO] [stdout] 504 | |         .into());
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -         )
[INFO] [stdout] 504 -         .into());
[INFO] [stdout] 503 +         ));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 500 ~         return Err(<CompilerError as Into<_>>::into(CompilerError::Generic(
[INFO] [stdout] 501 |             "asm() blocks currently do not support returning values directly. Use output operands."
[INFO] [stdout] 502 |                 .into(),
[INFO] [stdout] 503 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rcsharp` (bin "rcsharp" test) due to 37 previous errors
[INFO] [stderr] warning: unused dependency `regex`
[INFO] [stderr]  --> Cargo.toml:3:1
[INFO] [stderr]   |
[INFO] [stderr] 3 | regex = "1.11.2"
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `regex`
[INFO] [stderr] warning: `rcsharp` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456", kill_on_drop: false }`
[INFO] [stdout] 0f5bfaf34bdb0ee2ac7248191ce61a95c698f564511d7add2831385f42942456
