[INFO] cloning repository https://github.com/EMattfolk/GGJ2022
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/EMattfolk/GGJ2022" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FGGJ2022", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FGGJ2022'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 3d7af68c94ebef17ee650b1c52b3f8b3da6c0503
[INFO] checking EMattfolk/GGJ2022 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FGGJ2022" "/workspace/builds/worker-2-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-2-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/EMattfolk/GGJ2022
[INFO] finished tweaking git repo https://github.com/EMattfolk/GGJ2022
[INFO] tweaked toml for git repo https://github.com/EMattfolk/GGJ2022 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/EMattfolk/GGJ2022 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/EMattfolk/GGJ2022 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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] 26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a
[INFO] running `Command { std: "docker" "start" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a", 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" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a", 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" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.28
[INFO] [stderr]    Compiling syn v1.0.74
[INFO] [stderr]    Compiling libc v0.2.99
[INFO] [stderr]    Compiling utf8-ranges v1.0.4
[INFO] [stderr]    Compiling beef v0.5.1
[INFO] [stderr]    Compiling regex-syntax v0.6.25
[INFO] [stderr]    Compiling lazy_static v1.4.0
[INFO] [stderr]     Checking unicode-xid v0.2.2
[INFO] [stderr]    Compiling sylt v0.2.0 (/opt/rustwide/workdir/sylt)
[INFO] [stderr]     Checking sungod v0.3.1
[INFO] [stderr]     Checking quote v1.0.9
[INFO] [stderr]     Checking atty v0.2.14
[INFO] [stderr]     Checking colored v2.0.0
[INFO] [stderr]     Checking sylt-macro v0.2.0 (/opt/rustwide/workdir/sylt-macro)
[INFO] [stderr]    Compiling logos-derive v0.12.0
[INFO] [stderr]    Compiling gumdrop_derive v0.8.0
[INFO] [stderr]     Checking gumdrop v0.8.0
[INFO] [stderr]     Checking logos v0.12.0
[INFO] [stderr]     Checking sylt-tokenizer v0.2.0 (/opt/rustwide/workdir/sylt-tokenizer)
[INFO] [stderr]     Checking sylt-common v0.2.0 (/opt/rustwide/workdir/sylt-common)
[INFO] [stderr]     Checking sylt-parser v0.2.0 (/opt/rustwide/workdir/sylt-parser)
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:133:19
[INFO] [stdout]     |
[INFO] [stdout] 133 |       let mut ctx = expect!(ctx, T::Fn, "Expected 'fn' for function expression");
[INFO] [stdout]     |                     ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:142:21
[INFO] [stdout]     |
[INFO] [stdout] 142 |                       raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                       ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:164:21
[INFO] [stdout]     |
[INFO] [stdout] 164 |                       raise_syntax_error!(ctx, "Expected '->', 'do' or ',' after parameter")
[INFO] [stdout]     |                       ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:185:17
[INFO] [stdout]     |
[INFO] [stdout] 185 |                   raise_syntax_error!(ctx, "Didn't expect '{:?}' in function", t);
[INFO] [stdout]     |                   --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:291:13
[INFO] [stdout]     |
[INFO] [stdout] 291 |               raise_syntax_error!(ctx, "Cannot parse value, '{:?}' is not a valid value", t);
[INFO] [stdout]     |               ------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:334:13
[INFO] [stdout]     |
[INFO] [stdout] 334 |               raise_syntax_error!(ctx, "No valid expression starts with '{:?}'", t);
[INFO] [stdout]     |               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:352:13
[INFO] [stdout]     |
[INFO] [stdout] 352 |               raise_syntax_error!(ctx, "Invalid unary operator");
[INFO] [stdout]     |               -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:361:15
[INFO] [stdout]     |
[INFO] [stdout] 361 |       let ctx = expect!(ctx, T::Case, "Expected 'case' at start of case-expression");
[INFO] [stdout]     |                 -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:364:19
[INFO] [stdout]     |
[INFO] [stdout] 364 |       let mut ctx = expect!(ctx, T::Do, "Expected 'do' after case-expression");
[INFO] [stdout]     |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:386:25
[INFO] [stdout]     |
[INFO] [stdout] 386 |                           raise_syntax_error!(ctx, "Variables have to start with a lowercase letter");
[INFO] [stdout]     |                           --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:390:23
[INFO] [stdout]     |
[INFO] [stdout] 390 |                   ctx = expect!(ctx_, T::Arrow, "Expected '->' after case-pattern");
[INFO] [stdout]     |                         ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:398:17
[INFO] [stdout]     |
[INFO] [stdout] 398 |                   raise_syntax_error!(ctx, "Enum variants have to start with a captial letter");
[INFO] [stdout]     |                   ----------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:402:17
[INFO] [stdout]     |
[INFO] [stdout] 402 | /                 raise_syntax_error!(
[INFO] [stdout] 403 | |                     ctx,
[INFO] [stdout] 404 | |                     "Expected a branch - but a branch cannot start with {:?}",
[INFO] [stdout] 405 | |                     ctx.token()
[INFO] [stdout] 406 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:418:15
[INFO] [stdout]     |
[INFO] [stdout] 418 |       let ctx = expect!(ctx, T::End, "Expected 'end' to finish of case-statement");
[INFO] [stdout]     |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:431:15
[INFO] [stdout]     |
[INFO] [stdout] 431 |       let ctx = expect!(ctx, T::If, "Expected 'if' at start of if-expression");
[INFO] [stdout]     |                 -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:439:29
[INFO] [stdout]     |
[INFO] [stdout] 439 |       let (ctx, pass) = block(expect!(ctx, T::Do, "Expected 'do' after if condition"))?;
[INFO] [stdout]     |                               ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:455:15
[INFO] [stdout]     |
[INFO] [stdout] 455 |       let ctx = expect!(ctx, T::Arrow, "Expected '->' in arrow function call");
[INFO] [stdout]     |                 -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:482:17
[INFO] [stdout]     |
[INFO] [stdout] 482 |                   raise_syntax_error!(ctx, "Expected a call-expression after '->'");
[INFO] [stdout]     |                   ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:569:13
[INFO] [stdout]     |
[INFO] [stdout] 569 |               raise_syntax_error!(ctx.prev(), "Not a valid infix operator");
[INFO] [stdout]     |               ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:620:15
[INFO] [stdout]     |
[INFO] [stdout] 620 |       let ctx = expect!(ctx, T::LeftParen, "Expected '('");
[INFO] [stdout]     |                 ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:648:25
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           raise_syntax_error!(ctx, "Expected a ',' or ')' to end tuple argument");
[INFO] [stdout]     |                           ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:658:15
[INFO] [stdout]     |
[INFO] [stdout] 658 |       let ctx = expect!(ctx, T::RightParen, "Expected ',' or ')'");
[INFO] [stdout]     |                 -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:673:15
[INFO] [stdout]     |
[INFO] [stdout] 673 |       let ctx = expect!(ctx, T::LeftBrace, "Expected '{{' after blob name");
[INFO] [stdout]     |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:690:23
[INFO] [stdout]     |
[INFO] [stdout] 690 |                   ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name");
[INFO] [stdout]     |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:696:21
[INFO] [stdout]     |
[INFO] [stdout] 696 |                       raise_syntax_error!(ctx, "Expected a ',' between blob fields");
[INFO] [stdout]     |                       -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:704:17
[INFO] [stdout]     |
[INFO] [stdout] 704 |                   raise_syntax_error!(ctx, "Unexpected token ('{:?}') in blob initalizer", t);
[INFO] [stdout]     |                   --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:710:15
[INFO] [stdout]     |
[INFO] [stdout] 710 |       let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after blob initalizer");
[INFO] [stdout]     |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:713:9
[INFO] [stdout]     |
[INFO] [stdout] 713 |           raise_syntax_error!(ctx, "Parsed a blob not an if-statement");
[INFO] [stdout]     |           ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:723:15
[INFO] [stdout]     |
[INFO] [stdout] 723 |       let ctx = expect!(ctx, T::LeftBracket, "Expected '['");
[INFO] [stdout]     |                 -------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:740:17
[INFO] [stdout]     |
[INFO] [stdout] 740 | /                 expect!(
[INFO] [stdout] 741 | |                     ctx,
[INFO] [stdout] 742 | |                     T::Comma | T::RightBracket,
[INFO] [stdout] 743 | |                     "Expected ',' or ']' after element"
[INFO] [stdout] 744 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:751:15
[INFO] [stdout]     |
[INFO] [stdout] 751 |       let ctx = expect!(ctx, T::RightBracket, "Expected ']'");
[INFO] [stdout]     |                 --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:761:15
[INFO] [stdout]     |
[INFO] [stdout] 761 |       let ctx = expect!(ctx, T::LeftBrace, "Expected '{{'");
[INFO] [stdout]     |                 ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:779:21
[INFO] [stdout]     |
[INFO] [stdout] 779 | /                     raise_syntax_error!(
[INFO] [stdout] 780 | |                         ctx,
[INFO] [stdout] 781 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 782 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 783 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:800:27
[INFO] [stdout]     |
[INFO] [stdout] 800 |                       ctx = expect!(ctx, T::Colon, "Expected ':' for dict pair");
[INFO] [stdout]     |                             ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:808:21
[INFO] [stdout]     |
[INFO] [stdout] 808 | /                     raise_syntax_error!(
[INFO] [stdout] 809 | |                         ctx,
[INFO] [stdout] 810 | |                         "Expected an element delimiter ',' but got {:?}",
[INFO] [stdout] 811 | |                         ctx.token()
[INFO] [stdout] 812 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:820:15
[INFO] [stdout]     |
[INFO] [stdout] 820 |       let ctx = expect!(ctx, T::RightBrace, "Expected '}}'");
[INFO] [stdout]     |                 -------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:172:5
[INFO] [stdout]     |
[INFO] [stdout] 172 | /     expect!(
[INFO] [stdout] 173 | |         ctx,
[INFO] [stdout] 174 | |         T::Slash | T::Identifier(_),
[INFO] [stdout] 175 | |         "Expected identifier or slash at start of use path"
[INFO] [stdout] 176 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:207:17
[INFO] [stdout]     |
[INFO] [stdout] 207 |                   raise_syntax_error!(ctx, "Cannot import files from the standard library");
[INFO] [stdout]     |                   ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 428 |               let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:237:19
[INFO] [stdout]     |
[INFO] [stdout] 237 |           let err = syntax_error!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 238 | |             ctx,
[INFO] [stdout] 239 | |             "Expected \"do\" or a statement keyword, but found {:?}",
[INFO] [stdout] 240 | |             ctx.token()
[INFO] [stdout] 241 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 428 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:270:13
[INFO] [stdout]     |
[INFO] [stdout] 270 |             syntax_error!(ctx, "Expected 'end' after block");
[INFO] [stdout]     |             ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:295:13
[INFO] [stdout]     |
[INFO] [stdout] 295 |               raise_syntax_error!(ctx, "No valid statement starts with 'end'");
[INFO] [stdout]     |               ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:299:13
[INFO] [stdout]     |
[INFO] [stdout] 299 |               raise_syntax_error!(ctx, "No valid statement starts with 'else'");
[INFO] [stdout]     |               ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:320:32
[INFO] [stdout]     |
[INFO] [stdout] 320 |                   [T::As, ..] => raise_syntax_error!(ctx.skip(1), "Expected alias"),
[INFO] [stdout]     |                                  -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:323:25
[INFO] [stdout]     |
[INFO] [stdout] 323 |                           raise_syntax_error!(ctx, "Using root requires alias");
[INFO] [stdout]     |                           ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:350:27
[INFO] [stdout]     |
[INFO] [stdout] 350 |               let mut ctx = expect!(ctx, T::Use, "Expected 'use' after path");
[INFO] [stdout]     |                             ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:373:38
[INFO] [stdout]     |
[INFO] [stdout] 373 |   ...                   _ => raise_syntax_error!(ctx, "Expected identifier after 'as'"),
[INFO] [stdout]     |                              ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:384:29
[INFO] [stdout]     |
[INFO] [stdout] 384 |   ...                   raise_syntax_error!(ctx, "Expected ',' after import");
[INFO] [stdout]     |                         ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:388:26
[INFO] [stdout]     |
[INFO] [stdout] 388 |                       _ => raise_syntax_error!(ctx, "Expected identifier"),
[INFO] [stdout]     |                            ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:392:17
[INFO] [stdout]     |
[INFO] [stdout] 392 |                   raise_syntax_error!(ctx, "Something has to be imported in an import statement");
[INFO] [stdout]     |                   ------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:396:17
[INFO] [stdout]     |
[INFO] [stdout] 396 |                   expect!(ctx, T::RightParen, "Expected ')' after import list")
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:432:17
[INFO] [stdout]     |
[INFO] [stdout] 432 | /                 raise_syntax_error!(
[INFO] [stdout] 433 | |                     ctx,
[INFO] [stdout] 434 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 435 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:455:29
[INFO] [stdout]     |
[INFO] [stdout] 455 | / ...                   raise_syntax_error!(
[INFO] [stdout] 456 | | ...                       ctx,
[INFO] [stdout] 457 | | ...                       "Enum variants have to start with a capital letter"
[INFO] [stdout] 458 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:463:29
[INFO] [stdout]     |
[INFO] [stdout] 463 |   ...                   raise_syntax_error!(ctx, "Variant '{}' is declared twice", variant);
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:473:33
[INFO] [stdout]     |
[INFO] [stdout] 473 |   ...                   raise_syntax_error!(ctx, "Expected a deliminator ','");
[INFO] [stdout]     |                         ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:484:25
[INFO] [stdout]     |
[INFO] [stdout] 484 | /                         raise_syntax_error!(
[INFO] [stdout] 485 | |                             ctx,
[INFO] [stdout] 486 | |                             "Expected variant name or 'end' in enum statement"
[INFO] [stdout] 487 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:493:23
[INFO] [stdout]     |
[INFO] [stdout] 493 |               let ctx = expect!(ctx, T::End, "Expected 'end' to close enum");
[INFO] [stdout]     |                         ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:500:17
[INFO] [stdout]     |
[INFO] [stdout] 500 | /                 raise_syntax_error!(
[INFO] [stdout] 501 | |                     ctx,
[INFO] [stdout] 502 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 503 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:506:23
[INFO] [stdout]     |
[INFO] [stdout] 506 |               let ctx = expect!(ctx.skip(3), T::LeftBrace, "Expected '{{' to open blob");
[INFO] [stdout]     |                         ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:524:29
[INFO] [stdout]     |
[INFO] [stdout] 524 |   ...                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                         ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:527:29
[INFO] [stdout]     |
[INFO] [stdout] 527 |   ...                   raise_syntax_error!(ctx, "Field '{}' is declared twice", field);
[INFO] [stdout]     |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:529:31
[INFO] [stdout]     |
[INFO] [stdout] 529 |                           ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name");
[INFO] [stdout]     |                                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:535:29
[INFO] [stdout]     |
[INFO] [stdout] 535 |   ...                   raise_syntax_error!(ctx, "Expected a field deliminator ','");
[INFO] [stdout]     |                         ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:541:25
[INFO] [stdout]     |
[INFO] [stdout] 541 |                           raise_syntax_error!(ctx, "Expected field name or '}}' in blob statement");
[INFO] [stdout]     |                           ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:547:23
[INFO] [stdout]     |
[INFO] [stdout] 547 |               let ctx = expect!(ctx, T::RightBrace, "Expected '}}' to close blob fields");
[INFO] [stdout]     |                         ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:557:17
[INFO] [stdout]     |
[INFO] [stdout] 557 |                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:569:17
[INFO] [stdout]     |
[INFO] [stdout] 569 |                   raise_syntax_error!(ctx, "External definitons have to have a type");
[INFO] [stdout]     |                   ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:590:17
[INFO] [stdout]     |
[INFO] [stdout] 590 |                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:602:25
[INFO] [stdout]     |
[INFO] [stdout] 602 | /                         raise_syntax_error!(
[INFO] [stdout] 603 | |                             ctx,
[INFO] [stdout] 604 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 605 | |                             t
[INFO] [stdout] 606 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:637:25
[INFO] [stdout]     |
[INFO] [stdout] 637 |                           raise_syntax_error!(ctx, "No assignment operation matches '{:?}'", t);
[INFO] [stdout]     |                           --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:669:9
[INFO] [stdout]     |
[INFO] [stdout] 669 |           expect!(ctx, T::Newline, "Expected newline to end statement")
[INFO] [stdout]     |           ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:694:14
[INFO] [stdout]     |
[INFO] [stdout] 694 |           _ => raise_syntax_error!(ctx, "Not a valid outer statement"),
[INFO] [stdout]     |                ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 500 |                   raise_syntax_error!(ctx, "Expected a constraint argument, ',' or '+'");
[INFO] [stdout]     |                   ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 514 |               raise_syntax_error!(ctx, "Expected constraint name");
[INFO] [stdout]     |               ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 540 |                   let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace");
[INFO] [stdout]     |                             ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 562 |               let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace");
[INFO] [stdout]     |                         ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 568 |               raise_syntax_error!(ctx, "Failed to parse user-defined type");
[INFO] [stdout]     |               ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 634 |                               raise_syntax_error!(ctx, "Failed to parse type constraint");
[INFO] [stdout]     |                               ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 661 |                           raise_syntax_error!(ctx, "Didn't expect EOF in type definition");
[INFO] [stdout]     |                           ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 673 |                               raise_syntax_error!(ctx, "Expected ',' or '->' after type parameter")
[INFO] [stdout]     |                               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 707 |               let ctx = expect!(ctx, T::RightParen, "Expected ')' after tuple or grouping");
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 719 |               let ctx = expect!(ctx, T::RightBracket, "Expected ']' after list type");
[INFO] [stdout]     |                         ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 732 |                   let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after dict type");
[INFO] [stdout]     |                             ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 736 |                   let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after set type");
[INFO] [stdout]     |                             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 742 |               raise_syntax_error!(ctx, "No type starts with '{:?}'", t);
[INFO] [stdout]     |               --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 753 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 754 | |         ctx,
[INFO] [stdout] 755 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 756 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 757 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 795 |           expect!(ctx, T::RightParen, "Expected ')' after calling function")
[INFO] [stdout]     |           ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 808 |       let mut ctx = expect!(ctx, T::LeftBracket, "Expected '[' when indexing");
[INFO] [stdout]     |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 812 |       let ctx = expect!(ctx, T::RightBracket, "Expected ']' after index");
[INFO] [stdout]     |                 --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 844 |               raise_syntax_error!(ctx, "Indexing cannot lead into enum-variant");
[INFO] [stdout]     |               ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 847 |               raise_syntax_error!(ctx, "A function call cannot lead into enum-variant");
[INFO] [stdout]     |               ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 850 |               raise_syntax_error!(ctx, "Expressions cannot lead into enum-variant");
[INFO] [stdout]     |               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 854 |           raise_syntax_error!(ctx, "Enums have to start with a capital letter");
[INFO] [stdout]     |           --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 858 |       let ctx = expect!(ctx, T::Dot, "Expected '.' after variant name");
[INFO] [stdout]     |                 ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 862 |               raise_syntax_error!(ctx, "Enum variants have to start with a capital letter");
[INFO] [stdout]     |               ----------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 866 |           raise_syntax_error!(ctx, "Expected an identifier after '.' in variant");
[INFO] [stdout]     |           ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 894 | /         raise_syntax_error!(
[INFO] [stdout] 895 | |             ctx,
[INFO] [stdout] 896 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 897 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 935 | /         raise_syntax_error!(
[INFO] [stdout] 936 | |             ctx,
[INFO] [stdout] 937 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 938 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:403:42
[INFO] [stdout]     |
[INFO] [stdout] 388 | macro_rules! detail_if_error {
[INFO] [stdout] ...
[INFO] [stdout] 403 |                                 message: format!("{} - {}", prev_msg, format!($( $msg ),*)).into(),
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:793:21
[INFO] [stdout]     |
[INFO] [stdout] 793 |                     detail_if_error!(expression(ctx), "failed to parse dict or set")?;
[INFO] [stdout]     |                     ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing
[INFO] [stdout]    --> sylt-parser/src/parser.rs:856:5
[INFO] [stdout]     |
[INFO] [stdout] 856 |     drop(enum_name);
[INFO] [stdout]     |     ^^^^^---------^
[INFO] [stdout]     |          |
[INFO] [stdout]     |          argument has type `&Identifier`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dropping_references)]` on by default
[INFO] [stdout] help: use `let _ = ...` to ignore the expression or result
[INFO] [stdout]     |
[INFO] [stdout] 856 -     drop(enum_name);
[INFO] [stdout] 856 +     let _ = enum_name;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's named elsewhere is confusing
[INFO] [stdout]    --> sylt-parser/src/statement.rs:680:49
[INFO] [stdout]     |
[INFO] [stdout] 680 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<Statement> {
[INFO] [stdout]     |                                         --      ^^^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]     |                                         |
[INFO] [stdout]     |                                         the lifetime is named here
[INFO] [stdout]     |
[INFO] [stdout]     = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]     = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: consistently use `'t`
[INFO] [stdout]     |
[INFO] [stdout] 680 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<'t, Statement> {
[INFO] [stdout]     |                                                             +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sylt-parser` (lib) due to 98 previous errors; 2 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:133:19
[INFO] [stdout]     |
[INFO] [stdout] 133 |       let mut ctx = expect!(ctx, T::Fn, "Expected 'fn' for function expression");
[INFO] [stdout]     |                     ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:142:21
[INFO] [stdout]     |
[INFO] [stdout] 142 |                       raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                       ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:164:21
[INFO] [stdout]     |
[INFO] [stdout] 164 |                       raise_syntax_error!(ctx, "Expected '->', 'do' or ',' after parameter")
[INFO] [stdout]     |                       ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:185:17
[INFO] [stdout]     |
[INFO] [stdout] 185 |                   raise_syntax_error!(ctx, "Didn't expect '{:?}' in function", t);
[INFO] [stdout]     |                   --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:291:13
[INFO] [stdout]     |
[INFO] [stdout] 291 |               raise_syntax_error!(ctx, "Cannot parse value, '{:?}' is not a valid value", t);
[INFO] [stdout]     |               ------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:334:13
[INFO] [stdout]     |
[INFO] [stdout] 334 |               raise_syntax_error!(ctx, "No valid expression starts with '{:?}'", t);
[INFO] [stdout]     |               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:352:13
[INFO] [stdout]     |
[INFO] [stdout] 352 |               raise_syntax_error!(ctx, "Invalid unary operator");
[INFO] [stdout]     |               -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:361:15
[INFO] [stdout]     |
[INFO] [stdout] 361 |       let ctx = expect!(ctx, T::Case, "Expected 'case' at start of case-expression");
[INFO] [stdout]     |                 -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:364:19
[INFO] [stdout]     |
[INFO] [stdout] 364 |       let mut ctx = expect!(ctx, T::Do, "Expected 'do' after case-expression");
[INFO] [stdout]     |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:386:25
[INFO] [stdout]     |
[INFO] [stdout] 386 |                           raise_syntax_error!(ctx, "Variables have to start with a lowercase letter");
[INFO] [stdout]     |                           --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:390:23
[INFO] [stdout]     |
[INFO] [stdout] 390 |                   ctx = expect!(ctx_, T::Arrow, "Expected '->' after case-pattern");
[INFO] [stdout]     |                         ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:398:17
[INFO] [stdout]     |
[INFO] [stdout] 398 |                   raise_syntax_error!(ctx, "Enum variants have to start with a captial letter");
[INFO] [stdout]     |                   ----------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:402:17
[INFO] [stdout]     |
[INFO] [stdout] 402 | /                 raise_syntax_error!(
[INFO] [stdout] 403 | |                     ctx,
[INFO] [stdout] 404 | |                     "Expected a branch - but a branch cannot start with {:?}",
[INFO] [stdout] 405 | |                     ctx.token()
[INFO] [stdout] 406 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:418:15
[INFO] [stdout]     |
[INFO] [stdout] 418 |       let ctx = expect!(ctx, T::End, "Expected 'end' to finish of case-statement");
[INFO] [stdout]     |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:431:15
[INFO] [stdout]     |
[INFO] [stdout] 431 |       let ctx = expect!(ctx, T::If, "Expected 'if' at start of if-expression");
[INFO] [stdout]     |                 -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:439:29
[INFO] [stdout]     |
[INFO] [stdout] 439 |       let (ctx, pass) = block(expect!(ctx, T::Do, "Expected 'do' after if condition"))?;
[INFO] [stdout]     |                               ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:455:15
[INFO] [stdout]     |
[INFO] [stdout] 455 |       let ctx = expect!(ctx, T::Arrow, "Expected '->' in arrow function call");
[INFO] [stdout]     |                 -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:482:17
[INFO] [stdout]     |
[INFO] [stdout] 482 |                   raise_syntax_error!(ctx, "Expected a call-expression after '->'");
[INFO] [stdout]     |                   ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:569:13
[INFO] [stdout]     |
[INFO] [stdout] 569 |               raise_syntax_error!(ctx.prev(), "Not a valid infix operator");
[INFO] [stdout]     |               ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:620:15
[INFO] [stdout]     |
[INFO] [stdout] 620 |       let ctx = expect!(ctx, T::LeftParen, "Expected '('");
[INFO] [stdout]     |                 ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:648:25
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           raise_syntax_error!(ctx, "Expected a ',' or ')' to end tuple argument");
[INFO] [stdout]     |                           ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:658:15
[INFO] [stdout]     |
[INFO] [stdout] 658 |       let ctx = expect!(ctx, T::RightParen, "Expected ',' or ')'");
[INFO] [stdout]     |                 -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:673:15
[INFO] [stdout]     |
[INFO] [stdout] 673 |       let ctx = expect!(ctx, T::LeftBrace, "Expected '{{' after blob name");
[INFO] [stdout]     |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:690:23
[INFO] [stdout]     |
[INFO] [stdout] 690 |                   ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name");
[INFO] [stdout]     |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:696:21
[INFO] [stdout]     |
[INFO] [stdout] 696 |                       raise_syntax_error!(ctx, "Expected a ',' between blob fields");
[INFO] [stdout]     |                       -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:704:17
[INFO] [stdout]     |
[INFO] [stdout] 704 |                   raise_syntax_error!(ctx, "Unexpected token ('{:?}') in blob initalizer", t);
[INFO] [stdout]     |                   --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:710:15
[INFO] [stdout]     |
[INFO] [stdout] 710 |       let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after blob initalizer");
[INFO] [stdout]     |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:713:9
[INFO] [stdout]     |
[INFO] [stdout] 713 |           raise_syntax_error!(ctx, "Parsed a blob not an if-statement");
[INFO] [stdout]     |           ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:723:15
[INFO] [stdout]     |
[INFO] [stdout] 723 |       let ctx = expect!(ctx, T::LeftBracket, "Expected '['");
[INFO] [stdout]     |                 -------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:740:17
[INFO] [stdout]     |
[INFO] [stdout] 740 | /                 expect!(
[INFO] [stdout] 741 | |                     ctx,
[INFO] [stdout] 742 | |                     T::Comma | T::RightBracket,
[INFO] [stdout] 743 | |                     "Expected ',' or ']' after element"
[INFO] [stdout] 744 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:751:15
[INFO] [stdout]     |
[INFO] [stdout] 751 |       let ctx = expect!(ctx, T::RightBracket, "Expected ']'");
[INFO] [stdout]     |                 --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:761:15
[INFO] [stdout]     |
[INFO] [stdout] 761 |       let ctx = expect!(ctx, T::LeftBrace, "Expected '{{'");
[INFO] [stdout]     |                 ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:779:21
[INFO] [stdout]     |
[INFO] [stdout] 779 | /                     raise_syntax_error!(
[INFO] [stdout] 780 | |                         ctx,
[INFO] [stdout] 781 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 782 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 783 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:800:27
[INFO] [stdout]     |
[INFO] [stdout] 800 |                       ctx = expect!(ctx, T::Colon, "Expected ':' for dict pair");
[INFO] [stdout]     |                             ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:808:21
[INFO] [stdout]     |
[INFO] [stdout] 808 | /                     raise_syntax_error!(
[INFO] [stdout] 809 | |                         ctx,
[INFO] [stdout] 810 | |                         "Expected an element delimiter ',' but got {:?}",
[INFO] [stdout] 811 | |                         ctx.token()
[INFO] [stdout] 812 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:820:15
[INFO] [stdout]     |
[INFO] [stdout] 820 |       let ctx = expect!(ctx, T::RightBrace, "Expected '}}'");
[INFO] [stdout]     |                 -------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:172:5
[INFO] [stdout]     |
[INFO] [stdout] 172 | /     expect!(
[INFO] [stdout] 173 | |         ctx,
[INFO] [stdout] 174 | |         T::Slash | T::Identifier(_),
[INFO] [stdout] 175 | |         "Expected identifier or slash at start of use path"
[INFO] [stdout] 176 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:207:17
[INFO] [stdout]     |
[INFO] [stdout] 207 |                   raise_syntax_error!(ctx, "Cannot import files from the standard library");
[INFO] [stdout]     |                   ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 428 |               let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:237:19
[INFO] [stdout]     |
[INFO] [stdout] 237 |           let err = syntax_error!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 238 | |             ctx,
[INFO] [stdout] 239 | |             "Expected \"do\" or a statement keyword, but found {:?}",
[INFO] [stdout] 240 | |             ctx.token()
[INFO] [stdout] 241 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 428 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:270:13
[INFO] [stdout]     |
[INFO] [stdout] 270 |             syntax_error!(ctx, "Expected 'end' after block");
[INFO] [stdout]     |             ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:295:13
[INFO] [stdout]     |
[INFO] [stdout] 295 |               raise_syntax_error!(ctx, "No valid statement starts with 'end'");
[INFO] [stdout]     |               ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:299:13
[INFO] [stdout]     |
[INFO] [stdout] 299 |               raise_syntax_error!(ctx, "No valid statement starts with 'else'");
[INFO] [stdout]     |               ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:320:32
[INFO] [stdout]     |
[INFO] [stdout] 320 |                   [T::As, ..] => raise_syntax_error!(ctx.skip(1), "Expected alias"),
[INFO] [stdout]     |                                  -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:323:25
[INFO] [stdout]     |
[INFO] [stdout] 323 |                           raise_syntax_error!(ctx, "Using root requires alias");
[INFO] [stdout]     |                           ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:350:27
[INFO] [stdout]     |
[INFO] [stdout] 350 |               let mut ctx = expect!(ctx, T::Use, "Expected 'use' after path");
[INFO] [stdout]     |                             ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:373:38
[INFO] [stdout]     |
[INFO] [stdout] 373 |   ...                   _ => raise_syntax_error!(ctx, "Expected identifier after 'as'"),
[INFO] [stdout]     |                              ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:384:29
[INFO] [stdout]     |
[INFO] [stdout] 384 |   ...                   raise_syntax_error!(ctx, "Expected ',' after import");
[INFO] [stdout]     |                         ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:388:26
[INFO] [stdout]     |
[INFO] [stdout] 388 |                       _ => raise_syntax_error!(ctx, "Expected identifier"),
[INFO] [stdout]     |                            ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:392:17
[INFO] [stdout]     |
[INFO] [stdout] 392 |                   raise_syntax_error!(ctx, "Something has to be imported in an import statement");
[INFO] [stdout]     |                   ------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:396:17
[INFO] [stdout]     |
[INFO] [stdout] 396 |                   expect!(ctx, T::RightParen, "Expected ')' after import list")
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:432:17
[INFO] [stdout]     |
[INFO] [stdout] 432 | /                 raise_syntax_error!(
[INFO] [stdout] 433 | |                     ctx,
[INFO] [stdout] 434 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 435 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:455:29
[INFO] [stdout]     |
[INFO] [stdout] 455 | / ...                   raise_syntax_error!(
[INFO] [stdout] 456 | | ...                       ctx,
[INFO] [stdout] 457 | | ...                       "Enum variants have to start with a capital letter"
[INFO] [stdout] 458 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:463:29
[INFO] [stdout]     |
[INFO] [stdout] 463 |   ...                   raise_syntax_error!(ctx, "Variant '{}' is declared twice", variant);
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:473:33
[INFO] [stdout]     |
[INFO] [stdout] 473 |   ...                   raise_syntax_error!(ctx, "Expected a deliminator ','");
[INFO] [stdout]     |                         ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:484:25
[INFO] [stdout]     |
[INFO] [stdout] 484 | /                         raise_syntax_error!(
[INFO] [stdout] 485 | |                             ctx,
[INFO] [stdout] 486 | |                             "Expected variant name or 'end' in enum statement"
[INFO] [stdout] 487 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:493:23
[INFO] [stdout]     |
[INFO] [stdout] 493 |               let ctx = expect!(ctx, T::End, "Expected 'end' to close enum");
[INFO] [stdout]     |                         ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:500:17
[INFO] [stdout]     |
[INFO] [stdout] 500 | /                 raise_syntax_error!(
[INFO] [stdout] 501 | |                     ctx,
[INFO] [stdout] 502 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 503 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:506:23
[INFO] [stdout]     |
[INFO] [stdout] 506 |               let ctx = expect!(ctx.skip(3), T::LeftBrace, "Expected '{{' to open blob");
[INFO] [stdout]     |                         ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:524:29
[INFO] [stdout]     |
[INFO] [stdout] 524 |   ...                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                         ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:527:29
[INFO] [stdout]     |
[INFO] [stdout] 527 |   ...                   raise_syntax_error!(ctx, "Field '{}' is declared twice", field);
[INFO] [stdout]     |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:529:31
[INFO] [stdout]     |
[INFO] [stdout] 529 |                           ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name");
[INFO] [stdout]     |                                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:535:29
[INFO] [stdout]     |
[INFO] [stdout] 535 |   ...                   raise_syntax_error!(ctx, "Expected a field deliminator ','");
[INFO] [stdout]     |                         ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:541:25
[INFO] [stdout]     |
[INFO] [stdout] 541 |                           raise_syntax_error!(ctx, "Expected field name or '}}' in blob statement");
[INFO] [stdout]     |                           ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:547:23
[INFO] [stdout]     |
[INFO] [stdout] 547 |               let ctx = expect!(ctx, T::RightBrace, "Expected '}}' to close blob fields");
[INFO] [stdout]     |                         ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:557:17
[INFO] [stdout]     |
[INFO] [stdout] 557 |                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:569:17
[INFO] [stdout]     |
[INFO] [stdout] 569 |                   raise_syntax_error!(ctx, "External definitons have to have a type");
[INFO] [stdout]     |                   ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:590:17
[INFO] [stdout]     |
[INFO] [stdout] 590 |                   raise_syntax_error!(ctx, "\"self\" is a reserved identifier");
[INFO] [stdout]     |                   ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:602:25
[INFO] [stdout]     |
[INFO] [stdout] 602 | /                         raise_syntax_error!(
[INFO] [stdout] 603 | |                             ctx,
[INFO] [stdout] 604 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 605 | |                             t
[INFO] [stdout] 606 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:637:25
[INFO] [stdout]     |
[INFO] [stdout] 637 |                           raise_syntax_error!(ctx, "No assignment operation matches '{:?}'", t);
[INFO] [stdout]     |                           --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:669:9
[INFO] [stdout]     |
[INFO] [stdout] 669 |           expect!(ctx, T::Newline, "Expected newline to end statement")
[INFO] [stdout]     |           ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:694:14
[INFO] [stdout]     |
[INFO] [stdout] 694 |           _ => raise_syntax_error!(ctx, "Not a valid outer statement"),
[INFO] [stdout]     |                ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 500 |                   raise_syntax_error!(ctx, "Expected a constraint argument, ',' or '+'");
[INFO] [stdout]     |                   ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 514 |               raise_syntax_error!(ctx, "Expected constraint name");
[INFO] [stdout]     |               ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 540 |                   let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace");
[INFO] [stdout]     |                             ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 562 |               let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace");
[INFO] [stdout]     |                         ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 568 |               raise_syntax_error!(ctx, "Failed to parse user-defined type");
[INFO] [stdout]     |               ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 634 |                               raise_syntax_error!(ctx, "Failed to parse type constraint");
[INFO] [stdout]     |                               ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 661 |                           raise_syntax_error!(ctx, "Didn't expect EOF in type definition");
[INFO] [stdout]     |                           ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 673 |                               raise_syntax_error!(ctx, "Expected ',' or '->' after type parameter")
[INFO] [stdout]     |                               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 707 |               let ctx = expect!(ctx, T::RightParen, "Expected ')' after tuple or grouping");
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 719 |               let ctx = expect!(ctx, T::RightBracket, "Expected ']' after list type");
[INFO] [stdout]     |                         ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 732 |                   let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after dict type");
[INFO] [stdout]     |                             ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 736 |                   let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after set type");
[INFO] [stdout]     |                             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 742 |               raise_syntax_error!(ctx, "No type starts with '{:?}'", t);
[INFO] [stdout]     |               --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 753 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 754 | |         ctx,
[INFO] [stdout] 755 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 756 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 757 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 795 |           expect!(ctx, T::RightParen, "Expected ')' after calling function")
[INFO] [stdout]     |           ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 808 |       let mut ctx = expect!(ctx, T::LeftBracket, "Expected '[' when indexing");
[INFO] [stdout]     |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 812 |       let ctx = expect!(ctx, T::RightBracket, "Expected ']' after index");
[INFO] [stdout]     |                 --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 844 |               raise_syntax_error!(ctx, "Indexing cannot lead into enum-variant");
[INFO] [stdout]     |               ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 847 |               raise_syntax_error!(ctx, "A function call cannot lead into enum-variant");
[INFO] [stdout]     |               ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 850 |               raise_syntax_error!(ctx, "Expressions cannot lead into enum-variant");
[INFO] [stdout]     |               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 854 |           raise_syntax_error!(ctx, "Enums have to start with a capital letter");
[INFO] [stdout]     |           --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 858 |       let ctx = expect!(ctx, T::Dot, "Expected '.' after variant name");
[INFO] [stdout]     |                 ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 862 |               raise_syntax_error!(ctx, "Enum variants have to start with a capital letter");
[INFO] [stdout]     |               ----------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 866 |           raise_syntax_error!(ctx, "Expected an identifier after '.' in variant");
[INFO] [stdout]     |           ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 894 | /         raise_syntax_error!(
[INFO] [stdout] 895 | |             ctx,
[INFO] [stdout] 896 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 897 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:428:23
[INFO] [stdout]     |
[INFO] [stdout] 425 | / macro_rules! syntax_error {
[INFO] [stdout] 426 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 427 | |         {
[INFO] [stdout] 428 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 435 | |     };
[INFO] [stdout] 436 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error`
[INFO] [stdout] ...
[INFO] [stdout] 935 | /         raise_syntax_error!(
[INFO] [stdout] 936 | |             ctx,
[INFO] [stdout] 937 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 938 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:403:42
[INFO] [stdout]     |
[INFO] [stdout] 388 | macro_rules! detail_if_error {
[INFO] [stdout] ...
[INFO] [stdout] 403 |                                 message: format!("{} - {}", prev_msg, format!($( $msg ),*)).into(),
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/expression.rs:793:21
[INFO] [stdout]     |
[INFO] [stdout] 793 |                     detail_if_error!(expression(ctx), "failed to parse dict or set")?;
[INFO] [stdout]     |                     ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing
[INFO] [stdout]    --> sylt-parser/src/parser.rs:856:5
[INFO] [stdout]     |
[INFO] [stdout] 856 |     drop(enum_name);
[INFO] [stdout]     |     ^^^^^---------^
[INFO] [stdout]     |          |
[INFO] [stdout]     |          argument has type `&Identifier`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dropping_references)]` on by default
[INFO] [stdout] help: use `let _ = ...` to ignore the expression or result
[INFO] [stdout]     |
[INFO] [stdout] 856 -     drop(enum_name);
[INFO] [stdout] 856 +     let _ = enum_name;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's named elsewhere is confusing
[INFO] [stdout]    --> sylt-parser/src/statement.rs:680:49
[INFO] [stdout]     |
[INFO] [stdout] 680 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<Statement> {
[INFO] [stdout]     |                                         --      ^^^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]     |                                         |
[INFO] [stdout]     |                                         the lifetime is named here
[INFO] [stdout]     |
[INFO] [stdout]     = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]     = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: consistently use `'t`
[INFO] [stdout]     |
[INFO] [stdout] 680 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<'t, Statement> {
[INFO] [stdout]     |                                                             +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sylt-parser` (lib test) due to 98 previous errors; 2 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a", kill_on_drop: false }`
[INFO] [stdout] 26f56900c9b94da3013e4cccc2ae0aaa39fa1cb28bbea2d9bc87be3fde40ca5a
