[INFO] cloning repository https://github.com/EMattfolk/FallGameJam2021
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/EMattfolk/FallGameJam2021" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 14e12e47439ab0bb69ba4cb78305b9d873fca3aa
[INFO] checking EMattfolk/FallGameJam2021 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/EMattfolk/FallGameJam2021
[INFO] finished tweaking git repo https://github.com/EMattfolk/FallGameJam2021
[INFO] tweaked toml for git repo https://github.com/EMattfolk/FallGameJam2021 written to /workspace/builds/worker-3-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/EMattfolk/FallGameJam2021 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/FallGameJam2021 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e
[INFO] running `Command { std: "docker" "start" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", 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" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", 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" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e" "/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 utf8-ranges v1.0.4
[INFO] [stderr]    Compiling beef v0.5.1
[INFO] [stderr]    Compiling libc v0.2.99
[INFO] [stderr]    Compiling serde_derive v1.0.127
[INFO] [stderr]    Compiling serde v1.0.127
[INFO] [stderr]     Checking sungod v0.3.1
[INFO] [stderr]     Checking unicode-xid v0.2.2
[INFO] [stderr]    Compiling sylt v0.2.0 (/opt/rustwide/workdir/sylt)
[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] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> sylt-macro/src/macro.rs:464:9
[INFO] [stdout]     |
[INFO] [stdout] 464 |     let mut link = if let Some(link) = link.get_mut(&module) {
[INFO] [stdout]     |         ----^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> sylt-macro/src/macro.rs:464:9
[INFO] [stdout]     |
[INFO] [stdout] 464 |     let mut link = if let Some(link) = link.get_mut(&module) {
[INFO] [stdout]     |         ----^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling logos-derive v0.12.0
[INFO] [stderr]    Compiling gumdrop_derive v0.8.0
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> sylt-macro/src/macro.rs:464:9
[INFO] [stdout]     |
[INFO] [stdout] 464 |     let mut link = if let Some(link) = link.get_mut(&module) {
[INFO] [stdout]     |         ----^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[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 bincode v1.3.3
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> sylt-common/src/lib.rs:35:24
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn stack_from_base(&self, base: usize) -> Cow<[Value]>;
[INFO] [stdout]    |                        ^^^^^                  ^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]    |                        |
[INFO] [stdout]    |                        the lifetime is elided 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: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]>;
[INFO] [stdout]    |                                                   +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> sylt-common/src/lib.rs:35:24
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn stack_from_base(&self, base: usize) -> Cow<[Value]>;
[INFO] [stdout]    |                        ^^^^^                  ^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]    |                        |
[INFO] [stdout]    |                        the lifetime is elided 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: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]>;
[INFO] [stdout]    |                                                   +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Checking sylt-parser v0.2.0 (/opt/rustwide/workdir/sylt-parser)
[INFO] [stderr]     Checking sylt-machine v0.2.0 (/opt/rustwide/workdir/sylt-machine)
[INFO] [stderr]     Checking sylt-std v0.2.0 (/opt/rustwide/workdir/sylt-std)
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-machine/src/vm.rs:18:28
[INFO] [stdout]     |
[INFO] [stdout]  12 |   macro_rules! error {
[INFO] [stdout] ...
[INFO] [stdout]  18 |               let msg = Some(format!($( $msg ),*).into());
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 428 |                       value => error!(
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 429 | |                         self,
[INFO] [stdout] 430 | |                         RuntimeError::ValueError(op, vec![value]),
[INFO] [stdout] 431 | |                         "Not a function {:?}",
[INFO] [stdout] 432 | |                         value
[INFO] [stdout] 433 | |                     ),
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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-machine/src/vm.rs:18:28
[INFO] [stdout]     |
[INFO] [stdout]  12 | macro_rules! error {
[INFO] [stdout] ...
[INFO] [stdout]  18 |             let msg = Some(format!($( $msg ),*).into());
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 785 |                             Err(ek) => error!(self, ek, "Failed in external 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] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]    --> sylt-machine/src/vm.rs:256:24
[INFO] [stdout]     |
[INFO] [stdout] 256 |     fn stack_from_base(&self, base: usize) -> Cow<[Value]> {
[INFO] [stdout]     |                        ^^^^^                  ^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]     |                        |
[INFO] [stdout]     |                        the lifetime is elided 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: use `'_` for type paths
[INFO] [stdout]     |
[INFO] [stdout] 256 |     fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]> {
[INFO] [stdout]     |                                                   +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sylt-machine` (lib) due to 2 previous errors; 1 warning emitted
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-machine/src/vm.rs:18:28
[INFO] [stdout]     |
[INFO] [stdout]  12 |   macro_rules! error {
[INFO] [stdout] ...
[INFO] [stdout]  18 |               let msg = Some(format!($( $msg ),*).into());
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 428 |                       value => error!(
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 429 | |                         self,
[INFO] [stdout] 430 | |                         RuntimeError::ValueError(op, vec![value]),
[INFO] [stdout] 431 | |                         "Not a function {:?}",
[INFO] [stdout] 432 | |                         value
[INFO] [stdout] 433 | |                     ),
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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] [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-machine/src/vm.rs:18:28
[INFO] [stdout]     |
[INFO] [stdout]  12 | macro_rules! error {
[INFO] [stdout] ...
[INFO] [stdout]  18 |             let msg = Some(format!($( $msg ),*).into());
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 785 |                             Err(ek) => error!(self, ek, "Failed in external 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] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]    --> sylt-machine/src/vm.rs:256:24
[INFO] [stdout]     |
[INFO] [stdout] 256 |     fn stack_from_base(&self, base: usize) -> Cow<[Value]> {
[INFO] [stdout]     |                        ^^^^^                  ^^^^^^^^^^^^ the same lifetime is hidden here
[INFO] [stdout]     |                        |
[INFO] [stdout]     |                        the lifetime is elided 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: use `'_` for type paths
[INFO] [stdout]     |
[INFO] [stdout] 256 |     fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]> {
[INFO] [stdout]     |                                                   +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sylt-machine` (lib test) due to 2 previous errors; 1 warning emitted
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:117:21
[INFO] [stdout]     |
[INFO] [stdout] 117 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:139:21
[INFO] [stdout]     |
[INFO] [stdout] 139 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:160:17
[INFO] [stdout]     |
[INFO] [stdout] 160 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:262:13
[INFO] [stdout]     |
[INFO] [stdout] 262 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:303:13
[INFO] [stdout]     |
[INFO] [stdout] 303 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:321:13
[INFO] [stdout]     |
[INFO] [stdout] 321 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:329:15
[INFO] [stdout]     |
[INFO] [stdout] 329 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:334:15
[INFO] [stdout]     |
[INFO] [stdout] 334 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 335 | |         ctx,
[INFO] [stdout] 336 | |         T::Else,
[INFO] [stdout] 337 | |         "Expected 'else' after if-expression condition"
[INFO] [stdout] 338 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:350:15
[INFO] [stdout]     |
[INFO] [stdout] 350 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:377:17
[INFO] [stdout]     |
[INFO] [stdout] 377 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:493:15
[INFO] [stdout]     |
[INFO] [stdout] 493 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:521:25
[INFO] [stdout]     |
[INFO] [stdout] 521 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:531:15
[INFO] [stdout]     |
[INFO] [stdout] 531 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:546:15
[INFO] [stdout]     |
[INFO] [stdout] 546 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:563:23
[INFO] [stdout]     |
[INFO] [stdout] 563 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:21
[INFO] [stdout]     |
[INFO] [stdout] 569 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:577:17
[INFO] [stdout]     |
[INFO] [stdout] 577 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:583:15
[INFO] [stdout]     |
[INFO] [stdout] 583 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:586:9
[INFO] [stdout]     |
[INFO] [stdout] 586 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:596:15
[INFO] [stdout]     |
[INFO] [stdout] 596 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:613:17
[INFO] [stdout]     |
[INFO] [stdout] 613 | /                 expect!(
[INFO] [stdout] 614 | |                     ctx,
[INFO] [stdout] 615 | |                     T::Comma | T::RightBracket,
[INFO] [stdout] 616 | |                     "Expected ',' or ']' after element"
[INFO] [stdout] 617 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:624:15
[INFO] [stdout]     |
[INFO] [stdout] 624 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:634:15
[INFO] [stdout]     |
[INFO] [stdout] 634 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:652:21
[INFO] [stdout]     |
[INFO] [stdout] 652 | /                     raise_syntax_error!(
[INFO] [stdout] 653 | |                         ctx,
[INFO] [stdout] 654 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 655 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 656 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:27
[INFO] [stdout]     |
[INFO] [stdout] 673 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:681:21
[INFO] [stdout]     |
[INFO] [stdout] 681 | /                     raise_syntax_error!(
[INFO] [stdout] 682 | |                         ctx,
[INFO] [stdout] 683 | |                         "Expected an element delimiter ',' but got {:?}",
[INFO] [stdout] 684 | |                         ctx.token()
[INFO] [stdout] 685 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:693:15
[INFO] [stdout]     |
[INFO] [stdout] 693 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:193:5
[INFO] [stdout]     |
[INFO] [stdout] 193 | /     expect!(
[INFO] [stdout] 194 | |         ctx,
[INFO] [stdout] 195 | |         T::Slash | T::Identifier(_),
[INFO] [stdout] 196 | |         "Expected identifier or slash at start of use path"
[INFO] [stdout] 197 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |               let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:249:19
[INFO] [stdout]     |
[INFO] [stdout] 249 |           let err = syntax_error!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 250 | |             ctx,
[INFO] [stdout] 251 | |             "Expected \"do\" or a statement keyword, but found {:?}",
[INFO] [stdout] 252 | |             ctx.token()
[INFO] [stdout] 253 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:282:13
[INFO] [stdout]     |
[INFO] [stdout] 282 |             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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:307:13
[INFO] [stdout]     |
[INFO] [stdout] 307 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:311:13
[INFO] [stdout]     |
[INFO] [stdout] 311 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:322:21
[INFO] [stdout]     |
[INFO] [stdout] 322 |                     syntax_error!(ctx, "Neither a valid block nor a valid expression - inspects the two errors below"),
[INFO] [stdout]     |                     -------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:344:32
[INFO] [stdout]     |
[INFO] [stdout] 344 |                   [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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:347:25
[INFO] [stdout]     |
[INFO] [stdout] 347 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:374:27
[INFO] [stdout]     |
[INFO] [stdout] 374 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:397:38
[INFO] [stdout]     |
[INFO] [stdout] 397 |   ...                   _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:408:29
[INFO] [stdout]     |
[INFO] [stdout] 408 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:412:26
[INFO] [stdout]     |
[INFO] [stdout] 412 |                       _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:416:17
[INFO] [stdout]     |
[INFO] [stdout] 416 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:420:17
[INFO] [stdout]     |
[INFO] [stdout] 420 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:431:23
[INFO] [stdout]     |
[INFO] [stdout] 431 |               let ctx = expect!(
[INFO] [stdout]     |  _______________________-
[INFO] [stdout] 432 | |                 ctx,
[INFO] [stdout] 433 | |                 T::Is,
[INFO] [stdout] 434 | |                 "Expected 'is' after first type in 'is-check' statement"
[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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:436:23
[INFO] [stdout]     |
[INFO] [stdout] 436 |               let ctx = expect!(
[INFO] [stdout]     |  _______________________-
[INFO] [stdout] 437 | |                 ctx,
[INFO] [stdout] 438 | |                 T::Colon,
[INFO] [stdout] 439 | |                 "Expected ':' - only type constant are allowed in 'is-check' statements"
[INFO] [stdout] 440 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:482:27
[INFO] [stdout]     |
[INFO] [stdout] 482 |               let mut ctx = expect!(ctx, T::Do);
[INFO] [stdout]     |                             ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:504:33
[INFO] [stdout]     |
[INFO] [stdout] 504 | / ...                   raise_syntax_error!(
[INFO] [stdout] 505 | | ...                       ctx,
[INFO] [stdout] 506 | | ...                       "Variables have to start with a lowercase letter"
[INFO] [stdout] 507 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:518:25
[INFO] [stdout]     |
[INFO] [stdout] 518 | /                         raise_syntax_error!(
[INFO] [stdout] 519 | |                             ctx,
[INFO] [stdout] 520 | |                             "Enum variants have to start with a captial letter"
[INFO] [stdout] 521 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:525:25
[INFO] [stdout]     |
[INFO] [stdout] 525 | /                         raise_syntax_error!(
[INFO] [stdout] 526 | |                             ctx,
[INFO] [stdout] 527 | |                             "Expected a branch - but a branch cannot start with {:?}",
[INFO] [stdout] 528 | |                             ctx.token()
[INFO] [stdout] 529 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:533:23
[INFO] [stdout]     |
[INFO] [stdout] 533 |               let ctx = expect!(ctx, T::Else, "Expected - else on 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:537:23
[INFO] [stdout]     |
[INFO] [stdout] 537 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:584:17
[INFO] [stdout]     |
[INFO] [stdout] 584 | /                 raise_syntax_error!(
[INFO] [stdout] 585 | |                     ctx,
[INFO] [stdout] 586 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 587 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:607:29
[INFO] [stdout]     |
[INFO] [stdout] 607 | / ...                   raise_syntax_error!(
[INFO] [stdout] 608 | | ...                       ctx,
[INFO] [stdout] 609 | | ...                       "Enum variants have to start with a capital letter"
[INFO] [stdout] 610 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:615:29
[INFO] [stdout]     |
[INFO] [stdout] 615 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:625:33
[INFO] [stdout]     |
[INFO] [stdout] 625 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:636:25
[INFO] [stdout]     |
[INFO] [stdout] 636 | /                         raise_syntax_error!(
[INFO] [stdout] 637 | |                             ctx,
[INFO] [stdout] 638 | |                             "Expected variant name or 'end' in enum statement"
[INFO] [stdout] 639 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:645:23
[INFO] [stdout]     |
[INFO] [stdout] 645 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:652:17
[INFO] [stdout]     |
[INFO] [stdout] 652 | /                 raise_syntax_error!(
[INFO] [stdout] 653 | |                     ctx,
[INFO] [stdout] 654 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 655 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:658:23
[INFO] [stdout]     |
[INFO] [stdout] 658 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:676:29
[INFO] [stdout]     |
[INFO] [stdout] 676 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:679:29
[INFO] [stdout]     |
[INFO] [stdout] 679 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:681:31
[INFO] [stdout]     |
[INFO] [stdout] 681 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:687:29
[INFO] [stdout]     |
[INFO] [stdout] 687 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:693:25
[INFO] [stdout]     |
[INFO] [stdout] 693 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:699:23
[INFO] [stdout]     |
[INFO] [stdout] 699 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:709:17
[INFO] [stdout]     |
[INFO] [stdout] 709 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:721:17
[INFO] [stdout]     |
[INFO] [stdout] 721 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:742:17
[INFO] [stdout]     |
[INFO] [stdout] 742 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:754:25
[INFO] [stdout]     |
[INFO] [stdout] 754 | /                         raise_syntax_error!(
[INFO] [stdout] 755 | |                             ctx,
[INFO] [stdout] 756 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 757 | |                             t
[INFO] [stdout] 758 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:789:25
[INFO] [stdout]     |
[INFO] [stdout] 789 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:821:9
[INFO] [stdout]     |
[INFO] [stdout] 821 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:847:14
[INFO] [stdout]     |
[INFO] [stdout] 847 |           _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 493 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 507 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 533 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 555 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 561 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 626 |                               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 653 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 665 |                               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 699 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 711 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 724 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 728 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 734 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 745 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 746 | |         ctx,
[INFO] [stdout] 747 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 748 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 749 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 790 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 803 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 807 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 839 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 842 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 845 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 849 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 853 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 857 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 861 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 889 | /         raise_syntax_error!(
[INFO] [stdout] 890 | |             ctx,
[INFO] [stdout] 891 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 892 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 930 | /         raise_syntax_error!(
[INFO] [stdout] 931 | |             ctx,
[INFO] [stdout] 932 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 933 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:851:5
[INFO] [stdout]     |
[INFO] [stdout] 851 |     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] 851 -     drop(enum_name);
[INFO] [stdout] 851 +     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:832:49
[INFO] [stdout]     |
[INFO] [stdout] 832 | 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] 832 | 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 97 previous errors; 2 warnings emitted
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> sylt-parser/src/parser.rs:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:117:21
[INFO] [stdout]     |
[INFO] [stdout] 117 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:139:21
[INFO] [stdout]     |
[INFO] [stdout] 139 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:160:17
[INFO] [stdout]     |
[INFO] [stdout] 160 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:262:13
[INFO] [stdout]     |
[INFO] [stdout] 262 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:303:13
[INFO] [stdout]     |
[INFO] [stdout] 303 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:321:13
[INFO] [stdout]     |
[INFO] [stdout] 321 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:329:15
[INFO] [stdout]     |
[INFO] [stdout] 329 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:334:15
[INFO] [stdout]     |
[INFO] [stdout] 334 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 335 | |         ctx,
[INFO] [stdout] 336 | |         T::Else,
[INFO] [stdout] 337 | |         "Expected 'else' after if-expression condition"
[INFO] [stdout] 338 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:350:15
[INFO] [stdout]     |
[INFO] [stdout] 350 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:377:17
[INFO] [stdout]     |
[INFO] [stdout] 377 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:493:15
[INFO] [stdout]     |
[INFO] [stdout] 493 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:521:25
[INFO] [stdout]     |
[INFO] [stdout] 521 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:531:15
[INFO] [stdout]     |
[INFO] [stdout] 531 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:546:15
[INFO] [stdout]     |
[INFO] [stdout] 546 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:563:23
[INFO] [stdout]     |
[INFO] [stdout] 563 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:21
[INFO] [stdout]     |
[INFO] [stdout] 569 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:577:17
[INFO] [stdout]     |
[INFO] [stdout] 577 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:583:15
[INFO] [stdout]     |
[INFO] [stdout] 583 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:586:9
[INFO] [stdout]     |
[INFO] [stdout] 586 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:596:15
[INFO] [stdout]     |
[INFO] [stdout] 596 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:613:17
[INFO] [stdout]     |
[INFO] [stdout] 613 | /                 expect!(
[INFO] [stdout] 614 | |                     ctx,
[INFO] [stdout] 615 | |                     T::Comma | T::RightBracket,
[INFO] [stdout] 616 | |                     "Expected ',' or ']' after element"
[INFO] [stdout] 617 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:624:15
[INFO] [stdout]     |
[INFO] [stdout] 624 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:634:15
[INFO] [stdout]     |
[INFO] [stdout] 634 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:652:21
[INFO] [stdout]     |
[INFO] [stdout] 652 | /                     raise_syntax_error!(
[INFO] [stdout] 653 | |                         ctx,
[INFO] [stdout] 654 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 655 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 656 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:27
[INFO] [stdout]     |
[INFO] [stdout] 673 |                       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:681:21
[INFO] [stdout]     |
[INFO] [stdout] 681 | /                     raise_syntax_error!(
[INFO] [stdout] 682 | |                         ctx,
[INFO] [stdout] 683 | |                         "Expected an element delimiter ',' but got {:?}",
[INFO] [stdout] 684 | |                         ctx.token()
[INFO] [stdout] 685 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:693:15
[INFO] [stdout]     |
[INFO] [stdout] 693 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:193:5
[INFO] [stdout]     |
[INFO] [stdout] 193 | /     expect!(
[INFO] [stdout] 194 | |         ctx,
[INFO] [stdout] 195 | |         T::Slash | T::Identifier(_),
[INFO] [stdout] 196 | |         "Expected identifier or slash at start of use path"
[INFO] [stdout] 197 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |               let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:249:19
[INFO] [stdout]     |
[INFO] [stdout] 249 |           let err = syntax_error!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 250 | |             ctx,
[INFO] [stdout] 251 | |             "Expected \"do\" or a statement keyword, but found {:?}",
[INFO] [stdout] 252 | |             ctx.token()
[INFO] [stdout] 253 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:282:13
[INFO] [stdout]     |
[INFO] [stdout] 282 |             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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:307:13
[INFO] [stdout]     |
[INFO] [stdout] 307 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:311:13
[INFO] [stdout]     |
[INFO] [stdout] 311 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 421 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: sylt-parser/src/statement.rs:322:21
[INFO] [stdout]     |
[INFO] [stdout] 322 |                     syntax_error!(ctx, "Neither a valid block nor a valid expression - inspects the two errors below"),
[INFO] [stdout]     |                     -------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:344:32
[INFO] [stdout]     |
[INFO] [stdout] 344 |                   [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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:347:25
[INFO] [stdout]     |
[INFO] [stdout] 347 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:374:27
[INFO] [stdout]     |
[INFO] [stdout] 374 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:397:38
[INFO] [stdout]     |
[INFO] [stdout] 397 |   ...                   _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:408:29
[INFO] [stdout]     |
[INFO] [stdout] 408 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:412:26
[INFO] [stdout]     |
[INFO] [stdout] 412 |                       _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:416:17
[INFO] [stdout]     |
[INFO] [stdout] 416 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:420:17
[INFO] [stdout]     |
[INFO] [stdout] 420 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:431:23
[INFO] [stdout]     |
[INFO] [stdout] 431 |               let ctx = expect!(
[INFO] [stdout]     |  _______________________-
[INFO] [stdout] 432 | |                 ctx,
[INFO] [stdout] 433 | |                 T::Is,
[INFO] [stdout] 434 | |                 "Expected 'is' after first type in 'is-check' statement"
[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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:436:23
[INFO] [stdout]     |
[INFO] [stdout] 436 |               let ctx = expect!(
[INFO] [stdout]     |  _______________________-
[INFO] [stdout] 437 | |                 ctx,
[INFO] [stdout] 438 | |                 T::Colon,
[INFO] [stdout] 439 | |                 "Expected ':' - only type constant are allowed in 'is-check' statements"
[INFO] [stdout] 440 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:482:27
[INFO] [stdout]     |
[INFO] [stdout] 482 |               let mut ctx = expect!(ctx, T::Do);
[INFO] [stdout]     |                             ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:504:33
[INFO] [stdout]     |
[INFO] [stdout] 504 | / ...                   raise_syntax_error!(
[INFO] [stdout] 505 | | ...                       ctx,
[INFO] [stdout] 506 | | ...                       "Variables have to start with a lowercase letter"
[INFO] [stdout] 507 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:518:25
[INFO] [stdout]     |
[INFO] [stdout] 518 | /                         raise_syntax_error!(
[INFO] [stdout] 519 | |                             ctx,
[INFO] [stdout] 520 | |                             "Enum variants have to start with a captial letter"
[INFO] [stdout] 521 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:525:25
[INFO] [stdout]     |
[INFO] [stdout] 525 | /                         raise_syntax_error!(
[INFO] [stdout] 526 | |                             ctx,
[INFO] [stdout] 527 | |                             "Expected a branch - but a branch cannot start with {:?}",
[INFO] [stdout] 528 | |                             ctx.token()
[INFO] [stdout] 529 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:533:23
[INFO] [stdout]     |
[INFO] [stdout] 533 |               let ctx = expect!(ctx, T::Else, "Expected - else on 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:537:23
[INFO] [stdout]     |
[INFO] [stdout] 537 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:584:17
[INFO] [stdout]     |
[INFO] [stdout] 584 | /                 raise_syntax_error!(
[INFO] [stdout] 585 | |                     ctx,
[INFO] [stdout] 586 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 587 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:607:29
[INFO] [stdout]     |
[INFO] [stdout] 607 | / ...                   raise_syntax_error!(
[INFO] [stdout] 608 | | ...                       ctx,
[INFO] [stdout] 609 | | ...                       "Enum variants have to start with a capital letter"
[INFO] [stdout] 610 | | ...                   );
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:615:29
[INFO] [stdout]     |
[INFO] [stdout] 615 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:625:33
[INFO] [stdout]     |
[INFO] [stdout] 625 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:636:25
[INFO] [stdout]     |
[INFO] [stdout] 636 | /                         raise_syntax_error!(
[INFO] [stdout] 637 | |                             ctx,
[INFO] [stdout] 638 | |                             "Expected variant name or 'end' in enum statement"
[INFO] [stdout] 639 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:645:23
[INFO] [stdout]     |
[INFO] [stdout] 645 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:652:17
[INFO] [stdout]     |
[INFO] [stdout] 652 | /                 raise_syntax_error!(
[INFO] [stdout] 653 | |                     ctx,
[INFO] [stdout] 654 | |                     "User defined types have to start with a capital letter"
[INFO] [stdout] 655 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:658:23
[INFO] [stdout]     |
[INFO] [stdout] 658 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:676:29
[INFO] [stdout]     |
[INFO] [stdout] 676 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:679:29
[INFO] [stdout]     |
[INFO] [stdout] 679 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:681:31
[INFO] [stdout]     |
[INFO] [stdout] 681 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:687:29
[INFO] [stdout]     |
[INFO] [stdout] 687 |   ...                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:693:25
[INFO] [stdout]     |
[INFO] [stdout] 693 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:699:23
[INFO] [stdout]     |
[INFO] [stdout] 699 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:709:17
[INFO] [stdout]     |
[INFO] [stdout] 709 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:721:17
[INFO] [stdout]     |
[INFO] [stdout] 721 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:742:17
[INFO] [stdout]     |
[INFO] [stdout] 742 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:754:25
[INFO] [stdout]     |
[INFO] [stdout] 754 | /                         raise_syntax_error!(
[INFO] [stdout] 755 | |                             ctx,
[INFO] [stdout] 756 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 757 | |                             t
[INFO] [stdout] 758 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:789:25
[INFO] [stdout]     |
[INFO] [stdout] 789 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:821:9
[INFO] [stdout]     |
[INFO] [stdout] 821 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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:847:14
[INFO] [stdout]     |
[INFO] [stdout] 847 |           _ => 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 493 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 507 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 533 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 555 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 561 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 626 |                               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 653 |                           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 665 |                               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 699 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 711 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 724 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 728 |                   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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 734 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 745 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 746 | |         ctx,
[INFO] [stdout] 747 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 748 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 749 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 790 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 803 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 807 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 839 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 842 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 845 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 849 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 853 |       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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 857 |               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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 861 |           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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 889 | /         raise_syntax_error!(
[INFO] [stdout] 890 | |             ctx,
[INFO] [stdout] 891 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 892 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:421:23
[INFO] [stdout]     |
[INFO] [stdout] 418 | / macro_rules! syntax_error {
[INFO] [stdout] 419 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 420 | |         {
[INFO] [stdout] 421 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 428 | |     };
[INFO] [stdout] 429 | | }
[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] 930 | /         raise_syntax_error!(
[INFO] [stdout] 931 | |             ctx,
[INFO] [stdout] 932 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 933 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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:851:5
[INFO] [stdout]     |
[INFO] [stdout] 851 |     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] 851 -     drop(enum_name);
[INFO] [stdout] 851 +     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:832:49
[INFO] [stdout]     |
[INFO] [stdout] 832 | 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] 832 | 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 97 previous errors; 2 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }`
[INFO] [stdout] dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e
