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