[INFO] cloning repository https://github.com/EMattfolk/FallGameJam2021 [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/EMattfolk/FallGameJam2021" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] 14e12e47439ab0bb69ba4cb78305b9d873fca3aa [INFO] checking EMattfolk/FallGameJam2021 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FEMattfolk%2FFallGameJam2021" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/EMattfolk/FallGameJam2021 [INFO] finished tweaking git repo https://github.com/EMattfolk/FallGameJam2021 [INFO] tweaked toml for git repo https://github.com/EMattfolk/FallGameJam2021 written to /workspace/builds/worker-3-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/EMattfolk/FallGameJam2021 on toolchain 52995a223f2919dd3e2e427231db90a257350ded [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] crate git repo https://github.com/EMattfolk/FallGameJam2021 already has a lockfile, it will not be regenerated [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }` [INFO] [stdout] dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e [INFO] running `Command { std: "docker" "start" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.28 [INFO] [stderr] Compiling syn v1.0.74 [INFO] [stderr] Compiling utf8-ranges v1.0.4 [INFO] [stderr] Compiling beef v0.5.1 [INFO] [stderr] Compiling libc v0.2.99 [INFO] [stderr] Compiling serde_derive v1.0.127 [INFO] [stderr] Compiling serde v1.0.127 [INFO] [stderr] Checking sungod v0.3.1 [INFO] [stderr] Checking unicode-xid v0.2.2 [INFO] [stderr] Compiling sylt v0.2.0 (/opt/rustwide/workdir/sylt) [INFO] [stderr] Checking quote v1.0.9 [INFO] [stderr] Checking atty v0.2.14 [INFO] [stderr] Checking colored v2.0.0 [INFO] [stderr] Checking sylt-macro v0.2.0 (/opt/rustwide/workdir/sylt-macro) [INFO] [stdout] warning: variable does not need to be mutable [INFO] [stdout] --> sylt-macro/src/macro.rs:464:9 [INFO] [stdout] | [INFO] [stdout] 464 | let mut link = if let Some(link) = link.get_mut(&module) { [INFO] [stdout] | ----^^^^ [INFO] [stdout] | | [INFO] [stdout] | help: remove this `mut` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: variable does not need to be mutable [INFO] [stdout] --> sylt-macro/src/macro.rs:464:9 [INFO] [stdout] | [INFO] [stdout] 464 | let mut link = if let Some(link) = link.get_mut(&module) { [INFO] [stdout] | ----^^^^ [INFO] [stdout] | | [INFO] [stdout] | help: remove this `mut` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Compiling logos-derive v0.12.0 [INFO] [stderr] Compiling gumdrop_derive v0.8.0 [INFO] [stdout] warning: variable does not need to be mutable [INFO] [stdout] --> sylt-macro/src/macro.rs:464:9 [INFO] [stdout] | [INFO] [stdout] 464 | let mut link = if let Some(link) = link.get_mut(&module) { [INFO] [stdout] | ----^^^^ [INFO] [stdout] | | [INFO] [stdout] | help: remove this `mut` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Checking gumdrop v0.8.0 [INFO] [stderr] Checking logos v0.12.0 [INFO] [stderr] Checking sylt-tokenizer v0.2.0 (/opt/rustwide/workdir/sylt-tokenizer) [INFO] [stderr] Checking sylt-common v0.2.0 (/opt/rustwide/workdir/sylt-common) [INFO] [stderr] Checking bincode v1.3.3 [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> sylt-common/src/lib.rs:35:24 [INFO] [stdout] | [INFO] [stdout] 35 | fn stack_from_base(&self, base: usize) -> Cow<[Value]>; [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 35 | fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]>; [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> sylt-common/src/lib.rs:35:24 [INFO] [stdout] | [INFO] [stdout] 35 | fn stack_from_base(&self, base: usize) -> Cow<[Value]>; [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 35 | fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]>; [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Checking sylt-parser v0.2.0 (/opt/rustwide/workdir/sylt-parser) [INFO] [stderr] Checking sylt-machine v0.2.0 (/opt/rustwide/workdir/sylt-machine) [INFO] [stderr] Checking sylt-std v0.2.0 (/opt/rustwide/workdir/sylt-std) [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-machine/src/vm.rs:18:28 [INFO] [stdout] | [INFO] [stdout] 12 | macro_rules! error { [INFO] [stdout] ... [INFO] [stdout] 18 | let msg = Some(format!($( $msg ),*).into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 428 | value => error!( [INFO] [stdout] | ______________________________- [INFO] [stdout] 429 | | self, [INFO] [stdout] 430 | | RuntimeError::ValueError(op, vec![value]), [INFO] [stdout] 431 | | "Not a function {:?}", [INFO] [stdout] 432 | | value [INFO] [stdout] 433 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-machine/src/vm.rs:18:28 [INFO] [stdout] | [INFO] [stdout] 12 | macro_rules! error { [INFO] [stdout] ... [INFO] [stdout] 18 | let msg = Some(format!($( $msg ),*).into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 785 | Err(ek) => error!(self, ek, "Failed in external function"), [INFO] [stdout] | ----------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> sylt-machine/src/vm.rs:256:24 [INFO] [stdout] | [INFO] [stdout] 256 | fn stack_from_base(&self, base: usize) -> Cow<[Value]> { [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 256 | fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]> { [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `sylt-machine` (lib) due to 2 previous errors; 1 warning emitted [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-machine/src/vm.rs:18:28 [INFO] [stdout] | [INFO] [stdout] 12 | macro_rules! error { [INFO] [stdout] ... [INFO] [stdout] 18 | let msg = Some(format!($( $msg ),*).into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 428 | value => error!( [INFO] [stdout] | ______________________________- [INFO] [stdout] 429 | | self, [INFO] [stdout] 430 | | RuntimeError::ValueError(op, vec![value]), [INFO] [stdout] 431 | | "Not a function {:?}", [INFO] [stdout] 432 | | value [INFO] [stdout] 433 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-machine/src/vm.rs:18:28 [INFO] [stdout] | [INFO] [stdout] 12 | macro_rules! error { [INFO] [stdout] ... [INFO] [stdout] 18 | let msg = Some(format!($( $msg ),*).into()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 785 | Err(ek) => error!(self, ek, "Failed in external function"), [INFO] [stdout] | ----------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> sylt-machine/src/vm.rs:256:24 [INFO] [stdout] | [INFO] [stdout] 256 | fn stack_from_base(&self, base: usize) -> Cow<[Value]> { [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 256 | fn stack_from_base(&self, base: usize) -> Cow<'_, [Value]> { [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `sylt-machine` (lib test) due to 2 previous errors; 1 warning emitted [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:108:19 [INFO] [stdout] | [INFO] [stdout] 108 | let mut ctx = expect!(ctx, T::Fn, "Expected 'fn' for function expression"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:117:21 [INFO] [stdout] | [INFO] [stdout] 117 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:139:21 [INFO] [stdout] | [INFO] [stdout] 139 | raise_syntax_error!(ctx, "Expected '->', 'do' or ',' after parameter") [INFO] [stdout] | ---------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:160:17 [INFO] [stdout] | [INFO] [stdout] 160 | raise_syntax_error!(ctx, "Didn't expect '{:?}' in function", t); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:262:13 [INFO] [stdout] | [INFO] [stdout] 262 | raise_syntax_error!(ctx, "Cannot parse value, '{:?}' is not a valid value", t); [INFO] [stdout] | ------------------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:303:13 [INFO] [stdout] | [INFO] [stdout] 303 | raise_syntax_error!(ctx, "No valid expression starts with '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:321:13 [INFO] [stdout] | [INFO] [stdout] 321 | raise_syntax_error!(ctx, "Invalid unary operator"); [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:329:15 [INFO] [stdout] | [INFO] [stdout] 329 | let ctx = expect!(ctx, T::If, "Expected 'if' at start of if-expression"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:334:15 [INFO] [stdout] | [INFO] [stdout] 334 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 335 | | ctx, [INFO] [stdout] 336 | | T::Else, [INFO] [stdout] 337 | | "Expected 'else' after if-expression condition" [INFO] [stdout] 338 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:350:15 [INFO] [stdout] | [INFO] [stdout] 350 | let ctx = expect!(ctx, T::Arrow, "Expected '->' in arrow function call"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:377:17 [INFO] [stdout] | [INFO] [stdout] 377 | raise_syntax_error!(ctx, "Expected a call-expression after '->'"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:493:15 [INFO] [stdout] | [INFO] [stdout] 493 | let ctx = expect!(ctx, T::LeftParen, "Expected '('"); [INFO] [stdout] | ------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:521:25 [INFO] [stdout] | [INFO] [stdout] 521 | raise_syntax_error!(ctx, "Expected a ',' or ')' to end tuple argument"); [INFO] [stdout] | ----------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:531:15 [INFO] [stdout] | [INFO] [stdout] 531 | let ctx = expect!(ctx, T::RightParen, "Expected ',' or ')'"); [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:546:15 [INFO] [stdout] | [INFO] [stdout] 546 | let ctx = expect!(ctx, T::LeftBrace, "Expected '{{' after blob name"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:563:23 [INFO] [stdout] | [INFO] [stdout] 563 | ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name"); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:569:21 [INFO] [stdout] | [INFO] [stdout] 569 | raise_syntax_error!(ctx, "Expected a ',' between blob fields"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:577:17 [INFO] [stdout] | [INFO] [stdout] 577 | raise_syntax_error!(ctx, "Unexpected token ('{:?}') in blob initalizer", t); [INFO] [stdout] | --------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:583:15 [INFO] [stdout] | [INFO] [stdout] 583 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after blob initalizer"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:586:9 [INFO] [stdout] | [INFO] [stdout] 586 | raise_syntax_error!(ctx, "Parsed a blob not an if-statement"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:596:15 [INFO] [stdout] | [INFO] [stdout] 596 | let ctx = expect!(ctx, T::LeftBracket, "Expected '['"); [INFO] [stdout] | -------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:613:17 [INFO] [stdout] | [INFO] [stdout] 613 | / expect!( [INFO] [stdout] 614 | | ctx, [INFO] [stdout] 615 | | T::Comma | T::RightBracket, [INFO] [stdout] 616 | | "Expected ',' or ']' after element" [INFO] [stdout] 617 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:624:15 [INFO] [stdout] | [INFO] [stdout] 624 | let ctx = expect!(ctx, T::RightBracket, "Expected ']'"); [INFO] [stdout] | --------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:634:15 [INFO] [stdout] | [INFO] [stdout] 634 | let ctx = expect!(ctx, T::LeftBrace, "Expected '{{'"); [INFO] [stdout] | ------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:652:21 [INFO] [stdout] | [INFO] [stdout] 652 | / raise_syntax_error!( [INFO] [stdout] 653 | | ctx, [INFO] [stdout] 654 | | "Empty dict pair is invalid in a {}", [INFO] [stdout] 655 | | if is_dict { "dict" } else { "set" } [INFO] [stdout] 656 | | ); [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:673:27 [INFO] [stdout] | [INFO] [stdout] 673 | ctx = expect!(ctx, T::Colon, "Expected ':' for dict pair"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:681:21 [INFO] [stdout] | [INFO] [stdout] 681 | / raise_syntax_error!( [INFO] [stdout] 682 | | ctx, [INFO] [stdout] 683 | | "Expected an element delimiter ',' but got {:?}", [INFO] [stdout] 684 | | ctx.token() [INFO] [stdout] 685 | | ); [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:693:15 [INFO] [stdout] | [INFO] [stdout] 693 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}'"); [INFO] [stdout] | -------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:193:5 [INFO] [stdout] | [INFO] [stdout] 193 | / expect!( [INFO] [stdout] 194 | | ctx, [INFO] [stdout] 195 | | T::Slash | T::Identifier(_), [INFO] [stdout] 196 | | "Expected identifier or slash at start of use path" [INFO] [stdout] 197 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:249:19 [INFO] [stdout] | [INFO] [stdout] 249 | let err = syntax_error!( [INFO] [stdout] | ___________________- [INFO] [stdout] 250 | | ctx, [INFO] [stdout] 251 | | "Expected \"do\" or a statement keyword, but found {:?}", [INFO] [stdout] 252 | | ctx.token() [INFO] [stdout] 253 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:282:13 [INFO] [stdout] | [INFO] [stdout] 282 | syntax_error!(ctx, "Expected 'end' after block"); [INFO] [stdout] | ------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:307:13 [INFO] [stdout] | [INFO] [stdout] 307 | raise_syntax_error!(ctx, "No valid statement starts with 'end'"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:311:13 [INFO] [stdout] | [INFO] [stdout] 311 | raise_syntax_error!(ctx, "No valid statement starts with 'else'"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:322:21 [INFO] [stdout] | [INFO] [stdout] 322 | syntax_error!(ctx, "Neither a valid block nor a valid expression - inspects the two errors below"), [INFO] [stdout] | -------------------------------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:344:32 [INFO] [stdout] | [INFO] [stdout] 344 | [T::As, ..] => raise_syntax_error!(ctx.skip(1), "Expected alias"), [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:347:25 [INFO] [stdout] | [INFO] [stdout] 347 | raise_syntax_error!(ctx, "Using root requires alias"); [INFO] [stdout] | ----------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:374:27 [INFO] [stdout] | [INFO] [stdout] 374 | let mut ctx = expect!(ctx, T::Use, "Expected 'use' after path"); [INFO] [stdout] | ------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:397:38 [INFO] [stdout] | [INFO] [stdout] 397 | ... _ => raise_syntax_error!(ctx, "Expected identifier after 'as'"), [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:408:29 [INFO] [stdout] | [INFO] [stdout] 408 | ... raise_syntax_error!(ctx, "Expected ',' after import"); [INFO] [stdout] | ----------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:412:26 [INFO] [stdout] | [INFO] [stdout] 412 | _ => raise_syntax_error!(ctx, "Expected identifier"), [INFO] [stdout] | ----------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:416:17 [INFO] [stdout] | [INFO] [stdout] 416 | raise_syntax_error!(ctx, "Something has to be imported in an import statement"); [INFO] [stdout] | ------------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:420:17 [INFO] [stdout] | [INFO] [stdout] 420 | expect!(ctx, T::RightParen, "Expected ')' after import list") [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:431:23 [INFO] [stdout] | [INFO] [stdout] 431 | let ctx = expect!( [INFO] [stdout] | _______________________- [INFO] [stdout] 432 | | ctx, [INFO] [stdout] 433 | | T::Is, [INFO] [stdout] 434 | | "Expected 'is' after first type in 'is-check' statement" [INFO] [stdout] 435 | | ); [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:436:23 [INFO] [stdout] | [INFO] [stdout] 436 | let ctx = expect!( [INFO] [stdout] | _______________________- [INFO] [stdout] 437 | | ctx, [INFO] [stdout] 438 | | T::Colon, [INFO] [stdout] 439 | | "Expected ':' - only type constant are allowed in 'is-check' statements" [INFO] [stdout] 440 | | ); [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:482:27 [INFO] [stdout] | [INFO] [stdout] 482 | let mut ctx = expect!(ctx, T::Do); [INFO] [stdout] | ------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:504:33 [INFO] [stdout] | [INFO] [stdout] 504 | / ... raise_syntax_error!( [INFO] [stdout] 505 | | ... ctx, [INFO] [stdout] 506 | | ... "Variables have to start with a lowercase letter" [INFO] [stdout] 507 | | ... ); [INFO] [stdout] | |_______________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:518:25 [INFO] [stdout] | [INFO] [stdout] 518 | / raise_syntax_error!( [INFO] [stdout] 519 | | ctx, [INFO] [stdout] 520 | | "Enum variants have to start with a captial letter" [INFO] [stdout] 521 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:525:25 [INFO] [stdout] | [INFO] [stdout] 525 | / raise_syntax_error!( [INFO] [stdout] 526 | | ctx, [INFO] [stdout] 527 | | "Expected a branch - but a branch cannot start with {:?}", [INFO] [stdout] 528 | | ctx.token() [INFO] [stdout] 529 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:533:23 [INFO] [stdout] | [INFO] [stdout] 533 | let ctx = expect!(ctx, T::Else, "Expected - else on case-statement"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:537:23 [INFO] [stdout] | [INFO] [stdout] 537 | let ctx = expect!(ctx, T::End, "Expected 'end' to finish of case-statement"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:584:17 [INFO] [stdout] | [INFO] [stdout] 584 | / raise_syntax_error!( [INFO] [stdout] 585 | | ctx, [INFO] [stdout] 586 | | "User defined types have to start with a capital letter" [INFO] [stdout] 587 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:607:29 [INFO] [stdout] | [INFO] [stdout] 607 | / ... raise_syntax_error!( [INFO] [stdout] 608 | | ... ctx, [INFO] [stdout] 609 | | ... "Enum variants have to start with a capital letter" [INFO] [stdout] 610 | | ... ); [INFO] [stdout] | |_______________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:615:29 [INFO] [stdout] | [INFO] [stdout] 615 | ... raise_syntax_error!(ctx, "Variant '{}' is declared twice", variant); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:625:33 [INFO] [stdout] | [INFO] [stdout] 625 | ... raise_syntax_error!(ctx, "Expected a deliminator ','"); [INFO] [stdout] | ------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:636:25 [INFO] [stdout] | [INFO] [stdout] 636 | / raise_syntax_error!( [INFO] [stdout] 637 | | ctx, [INFO] [stdout] 638 | | "Expected variant name or 'end' in enum statement" [INFO] [stdout] 639 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:645:23 [INFO] [stdout] | [INFO] [stdout] 645 | let ctx = expect!(ctx, T::End, "Expected 'end' to close enum"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:652:17 [INFO] [stdout] | [INFO] [stdout] 652 | / raise_syntax_error!( [INFO] [stdout] 653 | | ctx, [INFO] [stdout] 654 | | "User defined types have to start with a capital letter" [INFO] [stdout] 655 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:658:23 [INFO] [stdout] | [INFO] [stdout] 658 | let ctx = expect!(ctx.skip(3), T::LeftBrace, "Expected '{{' to open blob"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:676:29 [INFO] [stdout] | [INFO] [stdout] 676 | ... raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | ... raise_syntax_error!(ctx, "Field '{}' is declared twice", field); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:681:31 [INFO] [stdout] | [INFO] [stdout] 681 | ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name"); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:687:29 [INFO] [stdout] | [INFO] [stdout] 687 | ... raise_syntax_error!(ctx, "Expected a field deliminator ','"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:693:25 [INFO] [stdout] | [INFO] [stdout] 693 | raise_syntax_error!(ctx, "Expected field name or '}}' in blob statement"); [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:699:23 [INFO] [stdout] | [INFO] [stdout] 699 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' to close blob fields"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:709:17 [INFO] [stdout] | [INFO] [stdout] 709 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:721:17 [INFO] [stdout] | [INFO] [stdout] 721 | raise_syntax_error!(ctx, "External definitons have to have a type"); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:742:17 [INFO] [stdout] | [INFO] [stdout] 742 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:754:25 [INFO] [stdout] | [INFO] [stdout] 754 | / raise_syntax_error!( [INFO] [stdout] 755 | | ctx, [INFO] [stdout] 756 | | "Expected ':' or '=' for definition, but got '{:?}'", [INFO] [stdout] 757 | | t [INFO] [stdout] 758 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:789:25 [INFO] [stdout] | [INFO] [stdout] 789 | raise_syntax_error!(ctx, "No assignment operation matches '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:821:9 [INFO] [stdout] | [INFO] [stdout] 821 | expect!(ctx, T::Newline, "Expected newline to end statement") [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:847:14 [INFO] [stdout] | [INFO] [stdout] 847 | _ => raise_syntax_error!(ctx, "Not a valid outer statement"), [INFO] [stdout] | ------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 493 | raise_syntax_error!(ctx, "Expected a constraint argument, ',' or '+'"); [INFO] [stdout] | ---------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 507 | raise_syntax_error!(ctx, "Expected constraint name"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 533 | let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 555 | let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 561 | raise_syntax_error!(ctx, "Failed to parse user-defined type"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 626 | raise_syntax_error!(ctx, "Failed to parse type constraint"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 653 | raise_syntax_error!(ctx, "Didn't expect EOF in type definition"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 665 | raise_syntax_error!(ctx, "Expected ',' or '->' after type parameter") [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 699 | let ctx = expect!(ctx, T::RightParen, "Expected ')' after tuple or grouping"); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 711 | let ctx = expect!(ctx, T::RightBracket, "Expected ']' after list type"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 724 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after dict type"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 728 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after set type"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 734 | raise_syntax_error!(ctx, "No type starts with '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 745 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 746 | | ctx, [INFO] [stdout] 747 | | T::Prime | T::LeftParen, [INFO] [stdout] 748 | | "Expected '(' or ' when calling function" [INFO] [stdout] 749 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 790 | expect!(ctx, T::RightParen, "Expected ')' after calling function") [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 803 | let mut ctx = expect!(ctx, T::LeftBracket, "Expected '[' when indexing"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 807 | let ctx = expect!(ctx, T::RightBracket, "Expected ']' after index"); [INFO] [stdout] | --------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 839 | raise_syntax_error!(ctx, "Indexing cannot lead into enum-variant"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 842 | raise_syntax_error!(ctx, "A function call cannot lead into enum-variant"); [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 845 | raise_syntax_error!(ctx, "Expressions cannot lead into enum-variant"); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 849 | raise_syntax_error!(ctx, "Enums have to start with a capital letter"); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 853 | let ctx = expect!(ctx, T::Dot, "Expected '.' after variant name"); [INFO] [stdout] | ------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 857 | raise_syntax_error!(ctx, "Enum variants have to start with a capital letter"); [INFO] [stdout] | ----------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 861 | raise_syntax_error!(ctx, "Expected an identifier after '.' in variant"); [INFO] [stdout] | ----------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 889 | / raise_syntax_error!( [INFO] [stdout] 890 | | ctx, [INFO] [stdout] 891 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 892 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 930 | / raise_syntax_error!( [INFO] [stdout] 931 | | ctx, [INFO] [stdout] 932 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 933 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing [INFO] [stdout] --> sylt-parser/src/parser.rs:851:5 [INFO] [stdout] | [INFO] [stdout] 851 | drop(enum_name); [INFO] [stdout] | ^^^^^---------^ [INFO] [stdout] | | [INFO] [stdout] | argument has type `&Identifier` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dropping_references)]` on by default [INFO] [stdout] help: use `let _ = ...` to ignore the expression or result [INFO] [stdout] | [INFO] [stdout] 851 - drop(enum_name); [INFO] [stdout] 851 + let _ = enum_name; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's named elsewhere is confusing [INFO] [stdout] --> sylt-parser/src/statement.rs:832:49 [INFO] [stdout] | [INFO] [stdout] 832 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult { [INFO] [stdout] | -- ^^^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is named here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: consistently use `'t` [INFO] [stdout] | [INFO] [stdout] 832 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<'t, Statement> { [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `sylt-parser` (lib) due to 97 previous errors; 2 warnings emitted [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:108:19 [INFO] [stdout] | [INFO] [stdout] 108 | let mut ctx = expect!(ctx, T::Fn, "Expected 'fn' for function expression"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:117:21 [INFO] [stdout] | [INFO] [stdout] 117 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:139:21 [INFO] [stdout] | [INFO] [stdout] 139 | raise_syntax_error!(ctx, "Expected '->', 'do' or ',' after parameter") [INFO] [stdout] | ---------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:160:17 [INFO] [stdout] | [INFO] [stdout] 160 | raise_syntax_error!(ctx, "Didn't expect '{:?}' in function", t); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:262:13 [INFO] [stdout] | [INFO] [stdout] 262 | raise_syntax_error!(ctx, "Cannot parse value, '{:?}' is not a valid value", t); [INFO] [stdout] | ------------------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:303:13 [INFO] [stdout] | [INFO] [stdout] 303 | raise_syntax_error!(ctx, "No valid expression starts with '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:321:13 [INFO] [stdout] | [INFO] [stdout] 321 | raise_syntax_error!(ctx, "Invalid unary operator"); [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:329:15 [INFO] [stdout] | [INFO] [stdout] 329 | let ctx = expect!(ctx, T::If, "Expected 'if' at start of if-expression"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:334:15 [INFO] [stdout] | [INFO] [stdout] 334 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 335 | | ctx, [INFO] [stdout] 336 | | T::Else, [INFO] [stdout] 337 | | "Expected 'else' after if-expression condition" [INFO] [stdout] 338 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:350:15 [INFO] [stdout] | [INFO] [stdout] 350 | let ctx = expect!(ctx, T::Arrow, "Expected '->' in arrow function call"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:377:17 [INFO] [stdout] | [INFO] [stdout] 377 | raise_syntax_error!(ctx, "Expected a call-expression after '->'"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:493:15 [INFO] [stdout] | [INFO] [stdout] 493 | let ctx = expect!(ctx, T::LeftParen, "Expected '('"); [INFO] [stdout] | ------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:521:25 [INFO] [stdout] | [INFO] [stdout] 521 | raise_syntax_error!(ctx, "Expected a ',' or ')' to end tuple argument"); [INFO] [stdout] | ----------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:531:15 [INFO] [stdout] | [INFO] [stdout] 531 | let ctx = expect!(ctx, T::RightParen, "Expected ',' or ')'"); [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:546:15 [INFO] [stdout] | [INFO] [stdout] 546 | let ctx = expect!(ctx, T::LeftBrace, "Expected '{{' after blob name"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:563:23 [INFO] [stdout] | [INFO] [stdout] 563 | ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name"); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:569:21 [INFO] [stdout] | [INFO] [stdout] 569 | raise_syntax_error!(ctx, "Expected a ',' between blob fields"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:577:17 [INFO] [stdout] | [INFO] [stdout] 577 | raise_syntax_error!(ctx, "Unexpected token ('{:?}') in blob initalizer", t); [INFO] [stdout] | --------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:583:15 [INFO] [stdout] | [INFO] [stdout] 583 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after blob initalizer"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:586:9 [INFO] [stdout] | [INFO] [stdout] 586 | raise_syntax_error!(ctx, "Parsed a blob not an if-statement"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:596:15 [INFO] [stdout] | [INFO] [stdout] 596 | let ctx = expect!(ctx, T::LeftBracket, "Expected '['"); [INFO] [stdout] | -------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:613:17 [INFO] [stdout] | [INFO] [stdout] 613 | / expect!( [INFO] [stdout] 614 | | ctx, [INFO] [stdout] 615 | | T::Comma | T::RightBracket, [INFO] [stdout] 616 | | "Expected ',' or ']' after element" [INFO] [stdout] 617 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:624:15 [INFO] [stdout] | [INFO] [stdout] 624 | let ctx = expect!(ctx, T::RightBracket, "Expected ']'"); [INFO] [stdout] | --------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:634:15 [INFO] [stdout] | [INFO] [stdout] 634 | let ctx = expect!(ctx, T::LeftBrace, "Expected '{{'"); [INFO] [stdout] | ------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:652:21 [INFO] [stdout] | [INFO] [stdout] 652 | / raise_syntax_error!( [INFO] [stdout] 653 | | ctx, [INFO] [stdout] 654 | | "Empty dict pair is invalid in a {}", [INFO] [stdout] 655 | | if is_dict { "dict" } else { "set" } [INFO] [stdout] 656 | | ); [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:673:27 [INFO] [stdout] | [INFO] [stdout] 673 | ctx = expect!(ctx, T::Colon, "Expected ':' for dict pair"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:681:21 [INFO] [stdout] | [INFO] [stdout] 681 | / raise_syntax_error!( [INFO] [stdout] 682 | | ctx, [INFO] [stdout] 683 | | "Expected an element delimiter ',' but got {:?}", [INFO] [stdout] 684 | | ctx.token() [INFO] [stdout] 685 | | ); [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/expression.rs:693:15 [INFO] [stdout] | [INFO] [stdout] 693 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}'"); [INFO] [stdout] | -------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:193:5 [INFO] [stdout] | [INFO] [stdout] 193 | / expect!( [INFO] [stdout] 194 | | ctx, [INFO] [stdout] 195 | | T::Slash | T::Identifier(_), [INFO] [stdout] 196 | | "Expected identifier or slash at start of use path" [INFO] [stdout] 197 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:249:19 [INFO] [stdout] | [INFO] [stdout] 249 | let err = syntax_error!( [INFO] [stdout] | ___________________- [INFO] [stdout] 250 | | ctx, [INFO] [stdout] 251 | | "Expected \"do\" or a statement keyword, but found {:?}", [INFO] [stdout] 252 | | ctx.token() [INFO] [stdout] 253 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:282:13 [INFO] [stdout] | [INFO] [stdout] 282 | syntax_error!(ctx, "Expected 'end' after block"); [INFO] [stdout] | ------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:307:13 [INFO] [stdout] | [INFO] [stdout] 307 | raise_syntax_error!(ctx, "No valid statement starts with 'end'"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:311:13 [INFO] [stdout] | [INFO] [stdout] 311 | raise_syntax_error!(ctx, "No valid statement starts with 'else'"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 421 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:322:21 [INFO] [stdout] | [INFO] [stdout] 322 | syntax_error!(ctx, "Neither a valid block nor a valid expression - inspects the two errors below"), [INFO] [stdout] | -------------------------------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:344:32 [INFO] [stdout] | [INFO] [stdout] 344 | [T::As, ..] => raise_syntax_error!(ctx.skip(1), "Expected alias"), [INFO] [stdout] | -------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:347:25 [INFO] [stdout] | [INFO] [stdout] 347 | raise_syntax_error!(ctx, "Using root requires alias"); [INFO] [stdout] | ----------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:374:27 [INFO] [stdout] | [INFO] [stdout] 374 | let mut ctx = expect!(ctx, T::Use, "Expected 'use' after path"); [INFO] [stdout] | ------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:397:38 [INFO] [stdout] | [INFO] [stdout] 397 | ... _ => raise_syntax_error!(ctx, "Expected identifier after 'as'"), [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:408:29 [INFO] [stdout] | [INFO] [stdout] 408 | ... raise_syntax_error!(ctx, "Expected ',' after import"); [INFO] [stdout] | ----------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:412:26 [INFO] [stdout] | [INFO] [stdout] 412 | _ => raise_syntax_error!(ctx, "Expected identifier"), [INFO] [stdout] | ----------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:416:17 [INFO] [stdout] | [INFO] [stdout] 416 | raise_syntax_error!(ctx, "Something has to be imported in an import statement"); [INFO] [stdout] | ------------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:420:17 [INFO] [stdout] | [INFO] [stdout] 420 | expect!(ctx, T::RightParen, "Expected ')' after import list") [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:431:23 [INFO] [stdout] | [INFO] [stdout] 431 | let ctx = expect!( [INFO] [stdout] | _______________________- [INFO] [stdout] 432 | | ctx, [INFO] [stdout] 433 | | T::Is, [INFO] [stdout] 434 | | "Expected 'is' after first type in 'is-check' statement" [INFO] [stdout] 435 | | ); [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:436:23 [INFO] [stdout] | [INFO] [stdout] 436 | let ctx = expect!( [INFO] [stdout] | _______________________- [INFO] [stdout] 437 | | ctx, [INFO] [stdout] 438 | | T::Colon, [INFO] [stdout] 439 | | "Expected ':' - only type constant are allowed in 'is-check' statements" [INFO] [stdout] 440 | | ); [INFO] [stdout] | |_____________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:482:27 [INFO] [stdout] | [INFO] [stdout] 482 | let mut ctx = expect!(ctx, T::Do); [INFO] [stdout] | ------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:504:33 [INFO] [stdout] | [INFO] [stdout] 504 | / ... raise_syntax_error!( [INFO] [stdout] 505 | | ... ctx, [INFO] [stdout] 506 | | ... "Variables have to start with a lowercase letter" [INFO] [stdout] 507 | | ... ); [INFO] [stdout] | |_______________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:518:25 [INFO] [stdout] | [INFO] [stdout] 518 | / raise_syntax_error!( [INFO] [stdout] 519 | | ctx, [INFO] [stdout] 520 | | "Enum variants have to start with a captial letter" [INFO] [stdout] 521 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:525:25 [INFO] [stdout] | [INFO] [stdout] 525 | / raise_syntax_error!( [INFO] [stdout] 526 | | ctx, [INFO] [stdout] 527 | | "Expected a branch - but a branch cannot start with {:?}", [INFO] [stdout] 528 | | ctx.token() [INFO] [stdout] 529 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:533:23 [INFO] [stdout] | [INFO] [stdout] 533 | let ctx = expect!(ctx, T::Else, "Expected - else on case-statement"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:537:23 [INFO] [stdout] | [INFO] [stdout] 537 | let ctx = expect!(ctx, T::End, "Expected 'end' to finish of case-statement"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:584:17 [INFO] [stdout] | [INFO] [stdout] 584 | / raise_syntax_error!( [INFO] [stdout] 585 | | ctx, [INFO] [stdout] 586 | | "User defined types have to start with a capital letter" [INFO] [stdout] 587 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:607:29 [INFO] [stdout] | [INFO] [stdout] 607 | / ... raise_syntax_error!( [INFO] [stdout] 608 | | ... ctx, [INFO] [stdout] 609 | | ... "Enum variants have to start with a capital letter" [INFO] [stdout] 610 | | ... ); [INFO] [stdout] | |_______________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:615:29 [INFO] [stdout] | [INFO] [stdout] 615 | ... raise_syntax_error!(ctx, "Variant '{}' is declared twice", variant); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:625:33 [INFO] [stdout] | [INFO] [stdout] 625 | ... raise_syntax_error!(ctx, "Expected a deliminator ','"); [INFO] [stdout] | ------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:636:25 [INFO] [stdout] | [INFO] [stdout] 636 | / raise_syntax_error!( [INFO] [stdout] 637 | | ctx, [INFO] [stdout] 638 | | "Expected variant name or 'end' in enum statement" [INFO] [stdout] 639 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:645:23 [INFO] [stdout] | [INFO] [stdout] 645 | let ctx = expect!(ctx, T::End, "Expected 'end' to close enum"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:652:17 [INFO] [stdout] | [INFO] [stdout] 652 | / raise_syntax_error!( [INFO] [stdout] 653 | | ctx, [INFO] [stdout] 654 | | "User defined types have to start with a capital letter" [INFO] [stdout] 655 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:658:23 [INFO] [stdout] | [INFO] [stdout] 658 | let ctx = expect!(ctx.skip(3), T::LeftBrace, "Expected '{{' to open blob"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:676:29 [INFO] [stdout] | [INFO] [stdout] 676 | ... raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | ... raise_syntax_error!(ctx, "Field '{}' is declared twice", field); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:681:31 [INFO] [stdout] | [INFO] [stdout] 681 | ctx = expect!(ctx.skip(1), T::Colon, "Expected ':' after field name"); [INFO] [stdout] | --------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:687:29 [INFO] [stdout] | [INFO] [stdout] 687 | ... raise_syntax_error!(ctx, "Expected a field deliminator ','"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:693:25 [INFO] [stdout] | [INFO] [stdout] 693 | raise_syntax_error!(ctx, "Expected field name or '}}' in blob statement"); [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:699:23 [INFO] [stdout] | [INFO] [stdout] 699 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' to close blob fields"); [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:709:17 [INFO] [stdout] | [INFO] [stdout] 709 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:721:17 [INFO] [stdout] | [INFO] [stdout] 721 | raise_syntax_error!(ctx, "External definitons have to have a type"); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:742:17 [INFO] [stdout] | [INFO] [stdout] 742 | raise_syntax_error!(ctx, "\"self\" is a reserved identifier"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:754:25 [INFO] [stdout] | [INFO] [stdout] 754 | / raise_syntax_error!( [INFO] [stdout] 755 | | ctx, [INFO] [stdout] 756 | | "Expected ':' or '=' for definition, but got '{:?}'", [INFO] [stdout] 757 | | t [INFO] [stdout] 758 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:789:25 [INFO] [stdout] | [INFO] [stdout] 789 | raise_syntax_error!(ctx, "No assignment operation matches '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:821:9 [INFO] [stdout] | [INFO] [stdout] 821 | expect!(ctx, T::Newline, "Expected newline to end statement") [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:847:14 [INFO] [stdout] | [INFO] [stdout] 847 | _ => raise_syntax_error!(ctx, "Not a valid outer statement"), [INFO] [stdout] | ------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 493 | raise_syntax_error!(ctx, "Expected a constraint argument, ',' or '+'"); [INFO] [stdout] | ---------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 507 | raise_syntax_error!(ctx, "Expected constraint name"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 533 | let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 555 | let ctx = expect!(ctx.skip(1), T::Dot, "Expected '.' after namespace"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 561 | raise_syntax_error!(ctx, "Failed to parse user-defined type"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 626 | raise_syntax_error!(ctx, "Failed to parse type constraint"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 653 | raise_syntax_error!(ctx, "Didn't expect EOF in type definition"); [INFO] [stdout] | ---------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 665 | raise_syntax_error!(ctx, "Expected ',' or '->' after type parameter") [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 699 | let ctx = expect!(ctx, T::RightParen, "Expected ')' after tuple or grouping"); [INFO] [stdout] | ------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 711 | let ctx = expect!(ctx, T::RightBracket, "Expected ']' after list type"); [INFO] [stdout] | ------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 724 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after dict type"); [INFO] [stdout] | ------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 728 | let ctx = expect!(ctx, T::RightBrace, "Expected '}}' after set type"); [INFO] [stdout] | ----------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 734 | raise_syntax_error!(ctx, "No type starts with '{:?}'", t); [INFO] [stdout] | --------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 745 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 746 | | ctx, [INFO] [stdout] 747 | | T::Prime | T::LeftParen, [INFO] [stdout] 748 | | "Expected '(' or ' when calling function" [INFO] [stdout] 749 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 790 | expect!(ctx, T::RightParen, "Expected ')' after calling function") [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 803 | let mut ctx = expect!(ctx, T::LeftBracket, "Expected '[' when indexing"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 807 | let ctx = expect!(ctx, T::RightBracket, "Expected ']' after index"); [INFO] [stdout] | --------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 839 | raise_syntax_error!(ctx, "Indexing cannot lead into enum-variant"); [INFO] [stdout] | ------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 842 | raise_syntax_error!(ctx, "A function call cannot lead into enum-variant"); [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 845 | raise_syntax_error!(ctx, "Expressions cannot lead into enum-variant"); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 849 | raise_syntax_error!(ctx, "Enums have to start with a capital letter"); [INFO] [stdout] | --------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 853 | let ctx = expect!(ctx, T::Dot, "Expected '.' after variant name"); [INFO] [stdout] | ------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 857 | raise_syntax_error!(ctx, "Enum variants have to start with a capital letter"); [INFO] [stdout] | ----------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 861 | raise_syntax_error!(ctx, "Expected an identifier after '.' in variant"); [INFO] [stdout] | ----------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 889 | / raise_syntax_error!( [INFO] [stdout] 890 | | ctx, [INFO] [stdout] 891 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 892 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:421:23 [INFO] [stdout] | [INFO] [stdout] 418 | / macro_rules! syntax_error { [INFO] [stdout] 419 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 420 | | { [INFO] [stdout] 421 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 428 | | }; [INFO] [stdout] 429 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 930 | / raise_syntax_error!( [INFO] [stdout] 931 | | ctx, [INFO] [stdout] 932 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 933 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calls to `std::mem::drop` with a reference instead of an owned value does nothing [INFO] [stdout] --> sylt-parser/src/parser.rs:851:5 [INFO] [stdout] | [INFO] [stdout] 851 | drop(enum_name); [INFO] [stdout] | ^^^^^---------^ [INFO] [stdout] | | [INFO] [stdout] | argument has type `&Identifier` [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dropping_references)]` on by default [INFO] [stdout] help: use `let _ = ...` to ignore the expression or result [INFO] [stdout] | [INFO] [stdout] 851 - drop(enum_name); [INFO] [stdout] 851 + let _ = enum_name; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's named elsewhere is confusing [INFO] [stdout] --> sylt-parser/src/statement.rs:832:49 [INFO] [stdout] | [INFO] [stdout] 832 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult { [INFO] [stdout] | -- ^^^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is named here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: consistently use `'t` [INFO] [stdout] | [INFO] [stdout] 832 | pub fn outer_statement<'t>(ctx: Context<'t>) -> ParseResult<'t, Statement> { [INFO] [stdout] | +++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `sylt-parser` (lib test) due to 97 previous errors; 2 warnings emitted [INFO] running `Command { std: "docker" "inspect" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e", kill_on_drop: false }` [INFO] [stdout] dd7eec07009e3cfcfe00d9ae7bc77dcd29824120f16d5005208d5dfd15ca3a0e