[INFO] fetching crate sylt-parser 0.1.0...
[INFO] checking sylt-parser-0.1.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate sylt-parser 0.1.0 into /workspace/builds/worker-6-tc2/source
[INFO] started tweaking crates.io crate sylt-parser 0.1.0
[INFO] finished tweaking crates.io crate sylt-parser 0.1.0
[INFO] tweaked toml for crates.io crate sylt-parser 0.1.0 written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate sylt-parser 0.1.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 18 packages to highest compatible versions
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790
[INFO] running `Command { std: "docker" "start" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790", 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" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790", 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" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling serde_core v1.0.229
[INFO] [stderr]    Compiling beef v0.5.2
[INFO] [stderr]    Compiling regex-syntax v0.6.29
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]     Checking owo-colors v2.1.0
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling logos-derive v0.12.1
[INFO] [stderr]    Compiling sylt-macro v0.1.0
[INFO] [stderr]     Checking logos v0.12.1
[INFO] [stderr]     Checking sylt-tokenizer v0.1.0
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking sylt-common v0.1.0
[INFO] [stderr]     Checking sylt-parser v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:117:19
[INFO] [stdout]     |
[INFO] [stdout] 117 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:128:23
[INFO] [stdout]     |
[INFO] [stdout] 128 |                   ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after parameter 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:138:21
[INFO] [stdout]     |
[INFO] [stdout] 138 |                       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:280:13
[INFO] [stdout]     |
[INFO] [stdout] 280 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:322:21
[INFO] [stdout]     |
[INFO] [stdout] 322 |                       raise_syntax_error!(ctx, "Neither a blob instantiation or an 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:328:13
[INFO] [stdout]     |
[INFO] [stdout] 328 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:346:13
[INFO] [stdout]     |
[INFO] [stdout] 346 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:356:15
[INFO] [stdout]     |
[INFO] [stdout] 356 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:364:15
[INFO] [stdout]     |
[INFO] [stdout] 364 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 365 | |         ctx,
[INFO] [stdout] 366 | |         T::Else,
[INFO] [stdout] 367 | |         "Expected 'else' after short if-expression condition"
[INFO] [stdout] 368 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:388:15
[INFO] [stdout]     |
[INFO] [stdout] 388 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:393:15
[INFO] [stdout]     |
[INFO] [stdout] 393 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 394 | |         ctx,
[INFO] [stdout] 395 | |         T::Else,
[INFO] [stdout] 396 | |         "Expected 'else' after if-expression condition"
[INFO] [stdout] 397 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:416:15
[INFO] [stdout]     |
[INFO] [stdout] 416 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:444:20
[INFO] [stdout]     |
[INFO] [stdout] 444 |               _ => { 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:556:15
[INFO] [stdout]     |
[INFO] [stdout] 556 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:585:15
[INFO] [stdout]     |
[INFO] [stdout] 585 |       let ctx = expect!(ctx, T::RightParen, "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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:603:15
[INFO] [stdout]     |
[INFO] [stdout] 603 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:620:23
[INFO] [stdout]     |
[INFO] [stdout] 620 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:626:21
[INFO] [stdout]     |
[INFO] [stdout] 626 | /                     raise_syntax_error!(
[INFO] [stdout] 627 | |                         ctx,
[INFO] [stdout] 628 | |                         "Expected a field delimiter ',' - but got {:?}",
[INFO] [stdout] 629 | |                         ctx.token()
[INFO] [stdout] 630 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:638:17
[INFO] [stdout]     |
[INFO] [stdout] 638 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:644:15
[INFO] [stdout]     |
[INFO] [stdout] 644 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:647:9
[INFO] [stdout]     |
[INFO] [stdout] 647 |           raise_syntax_error!(ctx, "Parsed a blob instance 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:663:15
[INFO] [stdout]     |
[INFO] [stdout] 663 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:686:15
[INFO] [stdout]     |
[INFO] [stdout] 686 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:702:15
[INFO] [stdout]     |
[INFO] [stdout] 702 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:720:21
[INFO] [stdout]     |
[INFO] [stdout] 720 | /                     raise_syntax_error!(
[INFO] [stdout] 721 | |                         ctx,
[INFO] [stdout] 722 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 723 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 724 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:740:27
[INFO] [stdout]     |
[INFO] [stdout] 740 |                       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:753:15
[INFO] [stdout]     |
[INFO] [stdout] 753 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:125:19
[INFO] [stdout]     |
[INFO] [stdout] 125 |       let mut ctx = expect!(ctx, T::LeftBrace, "Expected '{{' at start of 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:147:15
[INFO] [stdout]     |
[INFO] [stdout] 147 |       let ctx = expect!(ctx, T::RightBrace, "Expected }} after block 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:172:17
[INFO] [stdout]     |
[INFO] [stdout] 172 |                   raise_syntax_error!(ctx, "Neither a block nor a valid 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:191:23
[INFO] [stdout]     |
[INFO] [stdout] 191 |               let ctx = expect!(ctx, T::Is, "Expected 'is' after first type in 'is-check' 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:192:23
[INFO] [stdout]     |
[INFO] [stdout] 192 |               let ctx = expect!(ctx, T::Colon, "Expected ':' - only type constant are allowed in 'is-check' statements");
[INFO] [stdout]     |                         ------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:279:23
[INFO] [stdout]     |
[INFO] [stdout] 279 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:297:29
[INFO] [stdout]     |
[INFO] [stdout] 297 |   ...                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:299:31
[INFO] [stdout]     |
[INFO] [stdout] 299 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:305:29
[INFO] [stdout]     |
[INFO] [stdout] 305 |   ...                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:311:25
[INFO] [stdout]     |
[INFO] [stdout] 311 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:317:23
[INFO] [stdout]     |
[INFO] [stdout] 317 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:392:25
[INFO] [stdout]     |
[INFO] [stdout] 392 | /                         raise_syntax_error!(
[INFO] [stdout] 393 | |                             ctx,
[INFO] [stdout] 394 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 395 | |                             t
[INFO] [stdout] 396 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:431:25
[INFO] [stdout]     |
[INFO] [stdout] 431 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 278 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:452:25
[INFO] [stdout]     |
[INFO] [stdout] 452 |                         syntax_error!(ctx, "Neither an assignment or a 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:480:14
[INFO] [stdout]     |
[INFO] [stdout] 480 |           _ => 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 354 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 366 |                               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 388 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 400 |                               raise_syntax_error!(ctx, "Expected ',' or ')' after tuple 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 412 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 425 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 429 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 435 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 481 |       let mut ctx = expect!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 482 | |         ctx,
[INFO] [stdout] 483 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 484 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 485 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 513 |           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 529 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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, 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 555 | /         raise_syntax_error!(
[INFO] [stdout] 556 | |             ctx,
[INFO] [stdout] 557 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 558 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 601 | /         raise_syntax_error!(
[INFO] [stdout] 602 | |             ctx,
[INFO] [stdout] 603 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 604 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the 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 named elsewhere is confusing
[INFO] [stdout]    --> src/statement.rs:468:49
[INFO] [stdout]     |
[INFO] [stdout] 468 | 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] 468 | 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 57 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:117:19
[INFO] [stdout]     |
[INFO] [stdout] 117 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:128:23
[INFO] [stdout]     |
[INFO] [stdout] 128 |                   ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after parameter 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:138:21
[INFO] [stdout]     |
[INFO] [stdout] 138 |                       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:280:13
[INFO] [stdout]     |
[INFO] [stdout] 280 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:322:21
[INFO] [stdout]     |
[INFO] [stdout] 322 |                       raise_syntax_error!(ctx, "Neither a blob instantiation or an 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:328:13
[INFO] [stdout]     |
[INFO] [stdout] 328 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:346:13
[INFO] [stdout]     |
[INFO] [stdout] 346 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:356:15
[INFO] [stdout]     |
[INFO] [stdout] 356 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:364:15
[INFO] [stdout]     |
[INFO] [stdout] 364 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 365 | |         ctx,
[INFO] [stdout] 366 | |         T::Else,
[INFO] [stdout] 367 | |         "Expected 'else' after short if-expression condition"
[INFO] [stdout] 368 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:388:15
[INFO] [stdout]     |
[INFO] [stdout] 388 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:393:15
[INFO] [stdout]     |
[INFO] [stdout] 393 |       let ctx = expect!(
[INFO] [stdout]     |  _______________-
[INFO] [stdout] 394 | |         ctx,
[INFO] [stdout] 395 | |         T::Else,
[INFO] [stdout] 396 | |         "Expected 'else' after if-expression condition"
[INFO] [stdout] 397 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:416:15
[INFO] [stdout]     |
[INFO] [stdout] 416 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:444:20
[INFO] [stdout]     |
[INFO] [stdout] 444 |               _ => { 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:556:15
[INFO] [stdout]     |
[INFO] [stdout] 556 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:585:15
[INFO] [stdout]     |
[INFO] [stdout] 585 |       let ctx = expect!(ctx, T::RightParen, "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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:603:15
[INFO] [stdout]     |
[INFO] [stdout] 603 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:620:23
[INFO] [stdout]     |
[INFO] [stdout] 620 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:626:21
[INFO] [stdout]     |
[INFO] [stdout] 626 | /                     raise_syntax_error!(
[INFO] [stdout] 627 | |                         ctx,
[INFO] [stdout] 628 | |                         "Expected a field delimiter ',' - but got {:?}",
[INFO] [stdout] 629 | |                         ctx.token()
[INFO] [stdout] 630 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:638:17
[INFO] [stdout]     |
[INFO] [stdout] 638 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:644:15
[INFO] [stdout]     |
[INFO] [stdout] 644 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:647:9
[INFO] [stdout]     |
[INFO] [stdout] 647 |           raise_syntax_error!(ctx, "Parsed a blob instance 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:663:15
[INFO] [stdout]     |
[INFO] [stdout] 663 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:686:15
[INFO] [stdout]     |
[INFO] [stdout] 686 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:702:15
[INFO] [stdout]     |
[INFO] [stdout] 702 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/expression.rs:720:21
[INFO] [stdout]     |
[INFO] [stdout] 720 | /                     raise_syntax_error!(
[INFO] [stdout] 721 | |                         ctx,
[INFO] [stdout] 722 | |                         "Empty dict pair is invalid in a {}",
[INFO] [stdout] 723 | |                         if is_dict { "dict" } else { "set" }
[INFO] [stdout] 724 | |                     );
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:740:27
[INFO] [stdout]     |
[INFO] [stdout] 740 |                       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/expression.rs:753:15
[INFO] [stdout]     |
[INFO] [stdout] 753 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:125:19
[INFO] [stdout]     |
[INFO] [stdout] 125 |       let mut ctx = expect!(ctx, T::LeftBrace, "Expected '{{' at start of 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:147:15
[INFO] [stdout]     |
[INFO] [stdout] 147 |       let ctx = expect!(ctx, T::RightBrace, "Expected }} after block 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:172:17
[INFO] [stdout]     |
[INFO] [stdout] 172 |                   raise_syntax_error!(ctx, "Neither a block nor a valid 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:191:23
[INFO] [stdout]     |
[INFO] [stdout] 191 |               let ctx = expect!(ctx, T::Is, "Expected 'is' after first type in 'is-check' 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:192:23
[INFO] [stdout]     |
[INFO] [stdout] 192 |               let ctx = expect!(ctx, T::Colon, "Expected ':' - only type constant are allowed in 'is-check' statements");
[INFO] [stdout]     |                         ------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:279:23
[INFO] [stdout]     |
[INFO] [stdout] 279 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:297:29
[INFO] [stdout]     |
[INFO] [stdout] 297 |   ...                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:299:31
[INFO] [stdout]     |
[INFO] [stdout] 299 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:305:29
[INFO] [stdout]     |
[INFO] [stdout] 305 |   ...                   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] [stderr] error: could not compile `sylt-parser` (lib test) due to 57 previous errors; 1 warning emitted
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:311:25
[INFO] [stdout]     |
[INFO] [stdout] 311 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:317:23
[INFO] [stdout]     |
[INFO] [stdout] 317 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:392:25
[INFO] [stdout]     |
[INFO] [stdout] 392 | /                         raise_syntax_error!(
[INFO] [stdout] 393 | |                             ctx,
[INFO] [stdout] 394 | |                             "Expected ':' or '=' for definition, but got '{:?}'",
[INFO] [stdout] 395 | |                             t
[INFO] [stdout] 396 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:431:25
[INFO] [stdout]     |
[INFO] [stdout] 431 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 278 |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/statement.rs:452:25
[INFO] [stdout]     |
[INFO] [stdout] 452 |                         syntax_error!(ctx, "Neither an assignment or a 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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]    ::: src/statement.rs:480:14
[INFO] [stdout]     |
[INFO] [stdout] 480 |           _ => 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 354 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 366 |                               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 388 |                           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 400 |                               raise_syntax_error!(ctx, "Expected ',' or ')' after tuple 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 412 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 425 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 429 |                   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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 435 |               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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 481 |       let mut ctx = expect!(
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 482 | |         ctx,
[INFO] [stdout] 483 | |         T::Prime | T::LeftParen,
[INFO] [stdout] 484 | |         "Expected '(' or ' when calling function"
[INFO] [stdout] 485 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 513 |           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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout] ...
[INFO] [stdout] 529 |       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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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, 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]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 555 | /         raise_syntax_error!(
[INFO] [stdout] 556 | |             ctx,
[INFO] [stdout] 557 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 558 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<std::string::String as Into<std::string::String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::string::String`
[INFO] [stdout]    --> src/parser.rs:278:23
[INFO] [stdout]     |
[INFO] [stdout] 275 | / macro_rules! syntax_error {
[INFO] [stdout] 276 | |     ($ctx:expr, $( $msg:expr ),* ) => {
[INFO] [stdout] 277 | |         {
[INFO] [stdout] 278 | |             let msg = format!($( $msg ),*).into();
[INFO] [stdout]     | |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 285 | |     };
[INFO] [stdout] 286 | | }
[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] 601 | /         raise_syntax_error!(
[INFO] [stdout] 602 | |             ctx,
[INFO] [stdout] 603 | |             "Assignable expressions have to start with an identifier"
[INFO] [stdout] 604 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the 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 named elsewhere is confusing
[INFO] [stdout]    --> src/statement.rs:468:49
[INFO] [stdout]     |
[INFO] [stdout] 468 | 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] 468 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<'t, Statement> {
[INFO] [stdout]     |                                                             +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790", kill_on_drop: false }`
[INFO] [stdout] 1ced908c27e0df2ab9b6e438808e0f5a0fe4754cd81003827fd44b7174df3790
