[INFO] cloning repository https://github.com/FredTheDino/thidy-lang [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/FredTheDino/thidy-lang" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FFredTheDino%2Fthidy-lang", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FFredTheDino%2Fthidy-lang'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] 1b7ec677581cf1d9327d1faff1152a922db7cd1a [INFO] checking FredTheDino/thidy-lang against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FFredTheDino%2Fthidy-lang" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/FredTheDino/thidy-lang [INFO] finished tweaking git repo https://github.com/FredTheDino/thidy-lang [INFO] tweaked toml for git repo https://github.com/FredTheDino/thidy-lang written to /workspace/builds/worker-0-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/FredTheDino/thidy-lang 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/FredTheDino/thidy-lang 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-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-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] c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235 [INFO] running `Command { std: "docker" "start" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235", 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" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235", 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" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.28 [INFO] [stderr] Compiling syn v1.0.74 [INFO] [stderr] Compiling utf8-ranges v1.0.4 [INFO] [stderr] Compiling beef v0.5.1 [INFO] [stderr] Compiling libc v0.2.99 [INFO] [stderr] Compiling regex-syntax v0.6.25 [INFO] [stderr] Compiling lazy_static v1.4.0 [INFO] [stderr] Checking levenshtein v1.0.5 [INFO] [stderr] Compiling sylt v0.2.0 (/opt/rustwide/workdir/sylt) [INFO] [stderr] Checking unicode-xid v0.2.2 [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] [stdout] warning: field `1` is never read [INFO] [stdout] --> sylt-macro/src/macro.rs:350:31 [INFO] [stdout] | [INFO] [stdout] 350 | struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] | ------- ^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | field in this struct [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field [INFO] [stdout] | [INFO] [stdout] 350 - struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] 350 + struct ArgItem(Ident, (), Expr); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `1` is never read [INFO] [stdout] --> sylt-macro/src/macro.rs:350:31 [INFO] [stdout] | [INFO] [stdout] 350 | struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] | ------- ^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | field in this struct [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field [INFO] [stdout] | [INFO] [stdout] 350 - struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] 350 + struct ArgItem(Ident, (), Expr); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Compiling logos-derive v0.12.0 [INFO] [stderr] Compiling gumdrop_derive v0.8.0 [INFO] [stdout] warning: field `1` is never read [INFO] [stdout] --> sylt-macro/src/macro.rs:350:31 [INFO] [stdout] | [INFO] [stdout] 350 | struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] | ------- ^^^^^^^^^ [INFO] [stdout] | | [INFO] [stdout] | field in this struct [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field [INFO] [stdout] | [INFO] [stdout] 350 - struct ArgItem(Ident, Token![=], Expr); [INFO] [stdout] 350 + struct ArgItem(Ident, (), Expr); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Checking gumdrop v0.8.0 [INFO] [stderr] Checking logos v0.12.0 [INFO] [stderr] Checking sylt-tokenizer v0.2.0 (/opt/rustwide/workdir/sylt-tokenizer) [INFO] [stderr] Checking sylt-common v0.2.0 (/opt/rustwide/workdir/sylt-common) [INFO] [stderr] Checking 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:133:14 [INFO] [stdout] | [INFO] [stdout] 133 | _ => raise_syntax_error!(ctx, "Expected 'fn' or 'pu' 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:144:21 [INFO] [stdout] | [INFO] [stdout] 144 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:166:21 [INFO] [stdout] | [INFO] [stdout] 166 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:187:17 [INFO] [stdout] | [INFO] [stdout] 187 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:274:13 [INFO] [stdout] | [INFO] [stdout] 274 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:316:13 [INFO] [stdout] | [INFO] [stdout] 316 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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, "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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:343:15 [INFO] [stdout] | [INFO] [stdout] 343 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:346:19 [INFO] [stdout] | [INFO] [stdout] 346 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:368:25 [INFO] [stdout] | [INFO] [stdout] 368 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:372:23 [INFO] [stdout] | [INFO] [stdout] 372 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:380:17 [INFO] [stdout] | [INFO] [stdout] 380 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:384:17 [INFO] [stdout] | [INFO] [stdout] 384 | / raise_syntax_error!( [INFO] [stdout] 385 | | ctx, [INFO] [stdout] 386 | | "Expected a branch - but a branch cannot start with {:?}", [INFO] [stdout] 387 | | ctx.token() [INFO] [stdout] 388 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:400:15 [INFO] [stdout] | [INFO] [stdout] 400 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:413:15 [INFO] [stdout] | [INFO] [stdout] 413 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:417:29 [INFO] [stdout] | [INFO] [stdout] 417 | let (ctx, body) = 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:426:23 [INFO] [stdout] | [INFO] [stdout] 426 | let ctx = expect!(ctx, T::Elif); [INFO] [stdout] | --------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:430:37 [INFO] [stdout] | [INFO] [stdout] 430 | let (ctx, body) = block(expect!(ctx, T::Do, "Expected 'do' after elif 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:440:19 [INFO] [stdout] | [INFO] [stdout] 440 | let ctx = expect!(ctx, T::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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:452:15 [INFO] [stdout] | [INFO] [stdout] 452 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:479:17 [INFO] [stdout] | [INFO] [stdout] 479 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:564:13 [INFO] [stdout] | [INFO] [stdout] 564 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:614:15 [INFO] [stdout] | [INFO] [stdout] 614 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:642:25 [INFO] [stdout] | [INFO] [stdout] 642 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:652:15 [INFO] [stdout] | [INFO] [stdout] 652 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:667:15 [INFO] [stdout] | [INFO] [stdout] 667 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:684:23 [INFO] [stdout] | [INFO] [stdout] 684 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:690:21 [INFO] [stdout] | [INFO] [stdout] 690 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:698:17 [INFO] [stdout] | [INFO] [stdout] 698 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:704:15 [INFO] [stdout] | [INFO] [stdout] 704 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:707:9 [INFO] [stdout] | [INFO] [stdout] 707 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:717:15 [INFO] [stdout] | [INFO] [stdout] 717 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:734:17 [INFO] [stdout] | [INFO] [stdout] 734 | / expect!( [INFO] [stdout] 735 | | ctx, [INFO] [stdout] 736 | | T::Comma | T::RightBracket, [INFO] [stdout] 737 | | "Expected ',' or ']' after element" [INFO] [stdout] 738 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:745:15 [INFO] [stdout] | [INFO] [stdout] 745 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:179:5 [INFO] [stdout] | [INFO] [stdout] 179 | / expect!( [INFO] [stdout] 180 | | ctx, [INFO] [stdout] 181 | | T::Slash | T::Identifier(_), [INFO] [stdout] 182 | | "Expected identifier or slash at start of use path" [INFO] [stdout] 183 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:214:17 [INFO] [stdout] | [INFO] [stdout] 214 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 491 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:244:19 [INFO] [stdout] | [INFO] [stdout] 244 | let err = syntax_error!( [INFO] [stdout] | ___________________- [INFO] [stdout] 245 | | ctx, [INFO] [stdout] 246 | | "Expected \"do\" or a statement keyword, but found {:?}", [INFO] [stdout] 247 | | ctx.token() [INFO] [stdout] 248 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 491 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:277:13 [INFO] [stdout] | [INFO] [stdout] 277 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:302:13 [INFO] [stdout] | [INFO] [stdout] 302 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:306:13 [INFO] [stdout] | [INFO] [stdout] 306 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:327:32 [INFO] [stdout] | [INFO] [stdout] 327 | [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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:330:25 [INFO] [stdout] | [INFO] [stdout] 330 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:357:27 [INFO] [stdout] | [INFO] [stdout] 357 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:380:38 [INFO] [stdout] | [INFO] [stdout] 380 | ... _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:391:29 [INFO] [stdout] | [INFO] [stdout] 391 | ... 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:395:26 [INFO] [stdout] | [INFO] [stdout] 395 | _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:399:17 [INFO] [stdout] | [INFO] [stdout] 399 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:403:17 [INFO] [stdout] | [INFO] [stdout] 403 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:439:17 [INFO] [stdout] | [INFO] [stdout] 439 | / raise_syntax_error!( [INFO] [stdout] 440 | | ctx, [INFO] [stdout] 441 | | "User defined types have to start with a capital letter" [INFO] [stdout] 442 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:449:27 [INFO] [stdout] | [INFO] [stdout] 449 | let ctx = expect!(ctx, T::Star, "Type variables have to start with '*'"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:454:26 [INFO] [stdout] | [INFO] [stdout] 454 | _ => raise_syntax_error!( [INFO] [stdout] | __________________________- [INFO] [stdout] 455 | | ctx, [INFO] [stdout] 456 | | "Expected an identifier after '*' in type parameter" [INFO] [stdout] 457 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:462:17 [INFO] [stdout] | [INFO] [stdout] 462 | parse_beg_end_comma_sep!(ctx, T::LeftParen, T::RightParen, &item)?; [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:486:30 [INFO] [stdout] | [INFO] [stdout] 486 | _ => raise_syntax_error!( [INFO] [stdout] | ______________________________- [INFO] [stdout] 487 | | ctx, [INFO] [stdout] 488 | | "An enum variant has to start with a valid identifier" [INFO] [stdout] 489 | | ), [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:492:25 [INFO] [stdout] | [INFO] [stdout] 492 | / raise_syntax_error!( [INFO] [stdout] 493 | | ctx, [INFO] [stdout] 494 | | "Enum variants have to start with a capital letter" [INFO] [stdout] 495 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:507:29 [INFO] [stdout] | [INFO] [stdout] 507 | ... raise_syntax_error!(ctx, "Expected a delimiter ','"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:537:17 [INFO] [stdout] | [INFO] [stdout] 537 | / raise_syntax_error!( [INFO] [stdout] 538 | | ctx, [INFO] [stdout] 539 | | "User defined types have to start with a capital letter" [INFO] [stdout] 540 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:546:27 [INFO] [stdout] | [INFO] [stdout] 546 | let ctx = expect!(ctx, T::Star, "Type variables have to start with '*'"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:551:26 [INFO] [stdout] | [INFO] [stdout] 551 | _ => raise_syntax_error!( [INFO] [stdout] | __________________________- [INFO] [stdout] 552 | | ctx, [INFO] [stdout] 553 | | "Expected an identifier after '*' in type parameter" [INFO] [stdout] 554 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:562:17 [INFO] [stdout] | [INFO] [stdout] 562 | parse_beg_end_comma_sep!(ctx.skip(1), T::LeftParen, T::RightParen, &item)?; [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:564:23 [INFO] [stdout] | [INFO] [stdout] 564 | let ctx = expect!(ctx, 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:583:29 [INFO] [stdout] | [INFO] [stdout] 583 | ... 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:586:29 [INFO] [stdout] | [INFO] [stdout] 586 | ... raise_syntax_error!(ctx, "Field '{}' is declared twice", 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:588:31 [INFO] [stdout] | [INFO] [stdout] 588 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:594:29 [INFO] [stdout] | [INFO] [stdout] 594 | ... raise_syntax_error!(ctx, "Expected a field delimiter ','"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:600:25 [INFO] [stdout] | [INFO] [stdout] 600 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:606:23 [INFO] [stdout] | [INFO] [stdout] 606 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:616:17 [INFO] [stdout] | [INFO] [stdout] 616 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:628:17 [INFO] [stdout] | [INFO] [stdout] 628 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:649:17 [INFO] [stdout] | [INFO] [stdout] 649 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:661:25 [INFO] [stdout] | [INFO] [stdout] 661 | / raise_syntax_error!( [INFO] [stdout] 662 | | ctx, [INFO] [stdout] 663 | | "Expected ':' or '=' for definition, but got '{:?}'", [INFO] [stdout] 664 | | t [INFO] [stdout] 665 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:696:25 [INFO] [stdout] | [INFO] [stdout] 696 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:728:9 [INFO] [stdout] | [INFO] [stdout] 728 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:753:14 [INFO] [stdout] | [INFO] [stdout] 753 | _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 563 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 577 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 603 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 625 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 631 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] ... [INFO] [stdout] 654 | parse_beg_end_comma_sep!(ctx, T::LeftParen, T::RightParen, &parse_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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 700 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 727 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 739 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 781 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 793 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 798 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 809 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 810 | | ctx, [INFO] [stdout] 811 | | T::Prime | T::LeftParen, [INFO] [stdout] 812 | | "Expected '(' or ' when calling function" [INFO] [stdout] 813 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 851 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 864 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 871 | raise_syntax_error!(ctx, "Expected 'int' when parsing tuple 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 873 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 905 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 908 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 911 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 915 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 919 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 923 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 927 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 955 | / raise_syntax_error!( [INFO] [stdout] 956 | | ctx, [INFO] [stdout] 957 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 958 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 996 | / raise_syntax_error!( [INFO] [stdout] 997 | | ctx, [INFO] [stdout] 998 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 999 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [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:917:5 [INFO] [stdout] | [INFO] [stdout] 917 | 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] 917 - drop(enum_name); [INFO] [stdout] 917 + 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:739:49 [INFO] [stdout] | [INFO] [stdout] 739 | 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] 739 | 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 99 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:133:14 [INFO] [stdout] | [INFO] [stdout] 133 | _ => raise_syntax_error!(ctx, "Expected 'fn' or 'pu' 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:144:21 [INFO] [stdout] | [INFO] [stdout] 144 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:166:21 [INFO] [stdout] | [INFO] [stdout] 166 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:187:17 [INFO] [stdout] | [INFO] [stdout] 187 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:274:13 [INFO] [stdout] | [INFO] [stdout] 274 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:316:13 [INFO] [stdout] | [INFO] [stdout] 316 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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, "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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:343:15 [INFO] [stdout] | [INFO] [stdout] 343 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:346:19 [INFO] [stdout] | [INFO] [stdout] 346 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:368:25 [INFO] [stdout] | [INFO] [stdout] 368 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:372:23 [INFO] [stdout] | [INFO] [stdout] 372 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:380:17 [INFO] [stdout] | [INFO] [stdout] 380 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:384:17 [INFO] [stdout] | [INFO] [stdout] 384 | / raise_syntax_error!( [INFO] [stdout] 385 | | ctx, [INFO] [stdout] 386 | | "Expected a branch - but a branch cannot start with {:?}", [INFO] [stdout] 387 | | ctx.token() [INFO] [stdout] 388 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:400:15 [INFO] [stdout] | [INFO] [stdout] 400 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:413:15 [INFO] [stdout] | [INFO] [stdout] 413 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:417:29 [INFO] [stdout] | [INFO] [stdout] 417 | let (ctx, body) = 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:426:23 [INFO] [stdout] | [INFO] [stdout] 426 | let ctx = expect!(ctx, T::Elif); [INFO] [stdout] | --------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:430:37 [INFO] [stdout] | [INFO] [stdout] 430 | let (ctx, body) = block(expect!(ctx, T::Do, "Expected 'do' after elif 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:440:19 [INFO] [stdout] | [INFO] [stdout] 440 | let ctx = expect!(ctx, T::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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:452:15 [INFO] [stdout] | [INFO] [stdout] 452 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:479:17 [INFO] [stdout] | [INFO] [stdout] 479 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:564:13 [INFO] [stdout] | [INFO] [stdout] 564 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:614:15 [INFO] [stdout] | [INFO] [stdout] 614 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:642:25 [INFO] [stdout] | [INFO] [stdout] 642 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:652:15 [INFO] [stdout] | [INFO] [stdout] 652 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:667:15 [INFO] [stdout] | [INFO] [stdout] 667 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:684:23 [INFO] [stdout] | [INFO] [stdout] 684 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:690:21 [INFO] [stdout] | [INFO] [stdout] 690 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:698:17 [INFO] [stdout] | [INFO] [stdout] 698 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:704:15 [INFO] [stdout] | [INFO] [stdout] 704 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:707:9 [INFO] [stdout] | [INFO] [stdout] 707 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:717:15 [INFO] [stdout] | [INFO] [stdout] 717 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:734:17 [INFO] [stdout] | [INFO] [stdout] 734 | / expect!( [INFO] [stdout] 735 | | ctx, [INFO] [stdout] 736 | | T::Comma | T::RightBracket, [INFO] [stdout] 737 | | "Expected ',' or ']' after element" [INFO] [stdout] 738 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:745:15 [INFO] [stdout] | [INFO] [stdout] 745 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:179:5 [INFO] [stdout] | [INFO] [stdout] 179 | / expect!( [INFO] [stdout] 180 | | ctx, [INFO] [stdout] 181 | | T::Slash | T::Identifier(_), [INFO] [stdout] 182 | | "Expected identifier or slash at start of use path" [INFO] [stdout] 183 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:214:17 [INFO] [stdout] | [INFO] [stdout] 214 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 491 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:244:19 [INFO] [stdout] | [INFO] [stdout] 244 | let err = syntax_error!( [INFO] [stdout] | ___________________- [INFO] [stdout] 245 | | ctx, [INFO] [stdout] 246 | | "Expected \"do\" or a statement keyword, but found {:?}", [INFO] [stdout] 247 | | ctx.token() [INFO] [stdout] 248 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | macro_rules! syntax_error { [INFO] [stdout] ... [INFO] [stdout] 491 | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:277:13 [INFO] [stdout] | [INFO] [stdout] 277 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:302:13 [INFO] [stdout] | [INFO] [stdout] 302 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:306:13 [INFO] [stdout] | [INFO] [stdout] 306 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:327:32 [INFO] [stdout] | [INFO] [stdout] 327 | [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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:330:25 [INFO] [stdout] | [INFO] [stdout] 330 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:357:27 [INFO] [stdout] | [INFO] [stdout] 357 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:380:38 [INFO] [stdout] | [INFO] [stdout] 380 | ... _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:391:29 [INFO] [stdout] | [INFO] [stdout] 391 | ... 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:395:26 [INFO] [stdout] | [INFO] [stdout] 395 | _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:399:17 [INFO] [stdout] | [INFO] [stdout] 399 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:403:17 [INFO] [stdout] | [INFO] [stdout] 403 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:439:17 [INFO] [stdout] | [INFO] [stdout] 439 | / raise_syntax_error!( [INFO] [stdout] 440 | | ctx, [INFO] [stdout] 441 | | "User defined types have to start with a capital letter" [INFO] [stdout] 442 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:449:27 [INFO] [stdout] | [INFO] [stdout] 449 | let ctx = expect!(ctx, T::Star, "Type variables have to start with '*'"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:454:26 [INFO] [stdout] | [INFO] [stdout] 454 | _ => raise_syntax_error!( [INFO] [stdout] | __________________________- [INFO] [stdout] 455 | | ctx, [INFO] [stdout] 456 | | "Expected an identifier after '*' in type parameter" [INFO] [stdout] 457 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:462:17 [INFO] [stdout] | [INFO] [stdout] 462 | parse_beg_end_comma_sep!(ctx, T::LeftParen, T::RightParen, &item)?; [INFO] [stdout] | ----------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:486:30 [INFO] [stdout] | [INFO] [stdout] 486 | _ => raise_syntax_error!( [INFO] [stdout] | ______________________________- [INFO] [stdout] 487 | | ctx, [INFO] [stdout] 488 | | "An enum variant has to start with a valid identifier" [INFO] [stdout] 489 | | ), [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:492:25 [INFO] [stdout] | [INFO] [stdout] 492 | / raise_syntax_error!( [INFO] [stdout] 493 | | ctx, [INFO] [stdout] 494 | | "Enum variants have to start with a capital letter" [INFO] [stdout] 495 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:507:29 [INFO] [stdout] | [INFO] [stdout] 507 | ... raise_syntax_error!(ctx, "Expected a delimiter ','"); [INFO] [stdout] | ---------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:537:17 [INFO] [stdout] | [INFO] [stdout] 537 | / raise_syntax_error!( [INFO] [stdout] 538 | | ctx, [INFO] [stdout] 539 | | "User defined types have to start with a capital letter" [INFO] [stdout] 540 | | ); [INFO] [stdout] | |_________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:546:27 [INFO] [stdout] | [INFO] [stdout] 546 | let ctx = expect!(ctx, T::Star, "Type variables have to start with '*'"); [INFO] [stdout] | -------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:551:26 [INFO] [stdout] | [INFO] [stdout] 551 | _ => raise_syntax_error!( [INFO] [stdout] | __________________________- [INFO] [stdout] 552 | | ctx, [INFO] [stdout] 553 | | "Expected an identifier after '*' in type parameter" [INFO] [stdout] 554 | | ), [INFO] [stdout] | |_____________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] | [INFO] [stdout] ::: sylt-parser/src/statement.rs:562:17 [INFO] [stdout] | [INFO] [stdout] 562 | parse_beg_end_comma_sep!(ctx.skip(1), T::LeftParen, T::RightParen, &item)?; [INFO] [stdout] | ------------------------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:564:23 [INFO] [stdout] | [INFO] [stdout] 564 | let ctx = expect!(ctx, 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:583:29 [INFO] [stdout] | [INFO] [stdout] 583 | ... 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:586:29 [INFO] [stdout] | [INFO] [stdout] 586 | ... raise_syntax_error!(ctx, "Field '{}' is declared twice", 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:588:31 [INFO] [stdout] | [INFO] [stdout] 588 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:594:29 [INFO] [stdout] | [INFO] [stdout] 594 | ... raise_syntax_error!(ctx, "Expected a field delimiter ','"); [INFO] [stdout] | ---------------------------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:600:25 [INFO] [stdout] | [INFO] [stdout] 600 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:606:23 [INFO] [stdout] | [INFO] [stdout] 606 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:616:17 [INFO] [stdout] | [INFO] [stdout] 616 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:628:17 [INFO] [stdout] | [INFO] [stdout] 628 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:649:17 [INFO] [stdout] | [INFO] [stdout] 649 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:661:25 [INFO] [stdout] | [INFO] [stdout] 661 | / raise_syntax_error!( [INFO] [stdout] 662 | | ctx, [INFO] [stdout] 663 | | "Expected ':' or '=' for definition, but got '{:?}'", [INFO] [stdout] 664 | | t [INFO] [stdout] 665 | | ); [INFO] [stdout] | |_________________________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:696:25 [INFO] [stdout] | [INFO] [stdout] 696 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [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:728:9 [INFO] [stdout] | [INFO] [stdout] 728 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error 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:753:14 [INFO] [stdout] | [INFO] [stdout] 753 | _ => 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 563 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 577 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 603 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 625 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 631 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `parse_beg_end_comma_sep` [INFO] [stdout] ... [INFO] [stdout] 654 | parse_beg_end_comma_sep!(ctx, T::LeftParen, T::RightParen, &parse_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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 700 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 727 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 739 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 781 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 793 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 798 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 809 | let ctx = expect!( [INFO] [stdout] | _______________- [INFO] [stdout] 810 | | ctx, [INFO] [stdout] 811 | | T::Prime | T::LeftParen, [INFO] [stdout] 812 | | "Expected '(' or ' when calling function" [INFO] [stdout] 813 | | ); [INFO] [stdout] | |_____- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 851 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 864 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 871 | raise_syntax_error!(ctx, "Expected 'int' when parsing tuple 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 873 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 905 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 908 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 911 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 915 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect` [INFO] [stdout] ... [INFO] [stdout] 919 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 923 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 927 | 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:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 955 | / raise_syntax_error!( [INFO] [stdout] 956 | | ctx, [INFO] [stdout] 957 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 958 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `std::string::String` [INFO] [stdout] --> sylt-parser/src/parser.rs:491:23 [INFO] [stdout] | [INFO] [stdout] 488 | / macro_rules! syntax_error { [INFO] [stdout] 489 | | ($ctx:expr, $( $msg:expr ),* ) => { [INFO] [stdout] 490 | | { [INFO] [stdout] 491 | | let msg = format!($( $msg ),*).into(); [INFO] [stdout] | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... | [INFO] [stdout] 498 | | }; [INFO] [stdout] 499 | | } [INFO] [stdout] | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `raise_syntax_error` [INFO] [stdout] ... [INFO] [stdout] 996 | / raise_syntax_error!( [INFO] [stdout] 997 | | ctx, [INFO] [stdout] 998 | | "Assignable expressions have to start with an identifier" [INFO] [stdout] 999 | | ); [INFO] [stdout] | |_________- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [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:917:5 [INFO] [stdout] | [INFO] [stdout] 917 | 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] 917 - drop(enum_name); [INFO] [stdout] 917 + 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:739:49 [INFO] [stdout] | [INFO] [stdout] 739 | 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] 739 | 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 99 previous errors; 2 warnings emitted [INFO] running `Command { std: "docker" "inspect" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235", kill_on_drop: false }` [INFO] [stdout] c1a98c32a96e9f3d3c0a580325259e2cd200b15c3b881b1c56de44345c38d235