[INFO] fetching crate wasm-bindgen-macro-support-x 0.2.123-alpha.10...
[INFO] checking wasm-bindgen-macro-support-x-0.2.123-alpha.10 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate wasm-bindgen-macro-support-x 0.2.123-alpha.10 into /workspace/builds/worker-1-tc2/source
[INFO] started tweaking crates.io crate wasm-bindgen-macro-support-x 0.2.123-alpha.10
[INFO] finished tweaking crates.io crate wasm-bindgen-macro-support-x 0.2.123-alpha.10
[INFO] tweaked toml for crates.io crate wasm-bindgen-macro-support-x 0.2.123-alpha.10 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate wasm-bindgen-macro-support-x 0.2.123-alpha.10 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 crates.io crate wasm-bindgen-macro-support-x 0.2.123-alpha.10 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-1-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-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] 6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce
[INFO] running `Command { std: "docker" "start" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce", 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" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce", 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" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce" "/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.106
[INFO] [stderr]    Compiling wasm-bindgen-shared-x v0.2.123
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]    Compiling quote v1.0.45
[INFO] [stderr]     Checking syn v2.0.117
[INFO] [stderr]     Checking wasm-bindgen-macro-support-x v0.2.123-alpha.10 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/ast.rs:706:13
[INFO] [stdout]     |
[INFO] [stdout] 706 | /             bail_span!(
[INFO] [stdout] 707 | |                 syn::token::Pub(self.name_span),
[INFO] [stdout] 708 | |                 "setters must start with `set_`, found: {}",
[INFO] [stdout] 709 | |                 name,
[INFO] [stdout] 710 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::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: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/codegen.rs:868:13
[INFO] [stdout]     |
[INFO] [stdout] 868 |             bail_span!(syn_ret, "cannot return a borrowed ref with #[wasm_bindgen]",)
[INFO] [stdout]     |             ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2112:22
[INFO] [stdout]      |
[INFO] [stdout] 2112 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 2113 | |                     arg.pat_type.pat,
[INFO] [stdout] 2114 | |                     "unsupported pattern in #[wasm_bindgen] imported function",
[INFO] [stdout] 2115 | |                 ),
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2279:17
[INFO] [stdout]      |
[INFO] [stdout] 2279 | /                 bail_span!(
[INFO] [stdout] 2280 | |                     self.js_ret,
[INFO] [stdout] 2281 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 2282 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2619:25
[INFO] [stdout]      |
[INFO] [stdout] 2619 |                         bail_span!(gen_arg, "Functions must provide generic arguments");
[INFO] [stdout]      |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:263:21
[INFO] [stdout]     |
[INFO] [stdout] 263 |                     bail_span!(attr, "malformed #[wasm_bindgen] attribute")
[INFO] [stdout]     |                     ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:555:13
[INFO] [stdout]     |
[INFO] [stdout] 555 | /             bail_span!(
[INFO] [stdout] 556 | |                 self.generics,
[INFO] [stdout] 557 | |                 "structs with #[wasm_bindgen] cannot have lifetime or \
[INFO] [stdout] 558 | |                  type parameters currently"
[INFO] [stdout] 559 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:632:13
[INFO] [stdout]     |
[INFO] [stdout] 632 | /             bail_span!(
[INFO] [stdout] 633 | |                 self.ident,
[INFO] [stdout] 634 | |                 "struct cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 635 | |                 js_name
[INFO] [stdout] 636 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:778:13
[INFO] [stdout]     |
[INFO] [stdout] 778 |             bail_span!(&field.ty, "{}", msg);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:789:17
[INFO] [stdout]     |
[INFO] [stdout] 789 | /                 bail_span!(
[INFO] [stdout] 790 | |                     ident,
[INFO] [stdout] 791 | |                     "struct with `#[wasm_bindgen(extends = ...)]` cannot \
[INFO] [stdout] 792 | |                      have a field named `parent`; the macro injects one"
[INFO] [stdout] 793 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:816:13
[INFO] [stdout]     |
[INFO] [stdout] 816 | /             bail_span!(
[INFO] [stdout] 817 | |                 &s.ident,
[INFO] [stdout] 818 | |                 "tuple structs cannot use `#[wasm_bindgen(extends = ...)]`; \
[INFO] [stdout] 819 | |                  use a named-field struct"
[INFO] [stdout] 820 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:969:22
[INFO] [stdout]     |
[INFO] [stdout] 969 |                   _ => bail_span!(
[INFO] [stdout]     |  ______________________-
[INFO] [stdout] 970 | |                     class.pat_type.ty,
[INFO] [stdout] 971 | |                     "first argument of method must be a shared reference"
[INFO] [stdout] 972 | |                 ),
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:986:22
[INFO] [stdout]     |
[INFO] [stdout] 986 |                 _ => bail_span!(class_ty, "first argument of method must be a path"),
[INFO] [stdout]     |                      --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1025:22
[INFO] [stdout]      |
[INFO] [stdout] 1025 |                 _ => bail_span!(self, "constructor returns must be bare types"),
[INFO] [stdout]      |                      ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1032:22
[INFO] [stdout]      |
[INFO] [stdout] 1032 |                 _ => bail_span!(self, "return value of constructor must be a bare path"),
[INFO] [stdout]      |                      ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1237:13
[INFO] [stdout]      |
[INFO] [stdout] 1237 |             bail_span!(self.mutability, "cannot import mutable globals yet")
[INFO] [stdout]      |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1280:13
[INFO] [stdout]      |
[INFO] [stdout] 1280 |             bail_span!(self.mutability, "cannot import mutable globals yet")
[INFO] [stdout]      |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1290:13
[INFO] [stdout]      |
[INFO] [stdout] 1290 | /             bail_span!(
[INFO] [stdout] 1291 | |                 self.expr,
[INFO] [stdout] 1292 | |                 "statics with a value can only be string literals"
[INFO] [stdout] 1293 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1297:13
[INFO] [stdout]      |
[INFO] [stdout] 1297 | /             bail_span!(
[INFO] [stdout] 1298 | |                 self,
[INFO] [stdout] 1299 | |                 "static strings require `#[wasm_bindgen(static_string)]`"
[INFO] [stdout] 1300 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1306:13
[INFO] [stdout]      |
[INFO] [stdout] 1306 | /             bail_span!(
[INFO] [stdout] 1307 | |                 self,
[INFO] [stdout] 1308 | |                 "static strings require `#[wasm_bindgen(thread_local_v2)]`"
[INFO] [stdout] 1309 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1339:18
[INFO] [stdout]      |
[INFO] [stdout] 1339 |             _ => bail_span!(self, "can only #[wasm_bindgen] public functions"),
[INFO] [stdout]      |                  ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1342:13
[INFO] [stdout]      |
[INFO] [stdout] 1342 | /             bail_span!(
[INFO] [stdout] 1343 | |                 self.sig.constness,
[INFO] [stdout] 1344 | |                 "can only #[wasm_bindgen] non-const functions"
[INFO] [stdout] 1345 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1408:9
[INFO] [stdout]      |
[INFO] [stdout] 1408 |         bail_span!(sig.variadic, "can't #[wasm_bindgen] variadic functions");
[INFO] [stdout]      |         -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1413:9
[INFO] [stdout]      |
[INFO] [stdout] 1413 | /         bail_span!(
[INFO] [stdout] 1414 | |             sig.generics,
[INFO] [stdout] 1415 | |             "can't #[wasm_bindgen] functions with lifetime or type parameters"
[INFO] [stdout] 1416 | |         );
[INFO] [stdout]      | |_________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1476:25
[INFO] [stdout]      |
[INFO] [stdout] 1476 | / ...   bail_span!(
[INFO] [stdout] 1477 | | ...       r.self_token,
[INFO] [stdout] 1478 | | ...       "the `self` argument is only allowed for functions in `impl` blocks.\n\n\
[INFO] [stdout] 1479 | | ...       If the function is already in an `impl` block, did you perhaps forget to add `#[wasm_bindgen]` to the `impl` block?"
[INFO] [stdout] 1480 | | ...   );
[INFO] [stdout]      | |_______- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1483:25
[INFO] [stdout]      |
[INFO] [stdout] 1483 | /                         bail_span!(
[INFO] [stdout] 1484 | |                             r.self_token,
[INFO] [stdout] 1485 | |                             "the `self` argument is not allowed for `extern` functions.\n\n\
[INFO] [stdout] 1486 | |                             Did you perhaps mean `this`? For more information on importing JavaScript functions, see:\n\
[INFO] [stdout] 1487 | |                             https://wasm-bindgen.github.io/wasm-bindgen/examples/import-js.html"
[INFO] [stdout] 1488 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1772:25
[INFO] [stdout]      |
[INFO] [stdout] 1772 |                         bail_span!(&f.sig.generics, "the start function cannot have generics",);
[INFO] [stdout]      |                         ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1775:25
[INFO] [stdout]      |
[INFO] [stdout] 1775 |                         bail_span!(&f.sig.inputs, "the start function cannot have arguments",);
[INFO] [stdout]      |                         ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1794:21
[INFO] [stdout]      |
[INFO] [stdout] 1794 | /                     bail_span!(
[INFO] [stdout] 1795 | |                         &f.sig.inputs,
[INFO] [stdout] 1796 | |                         "functions taking a 'this' argument must have at least one parameter"
[INFO] [stdout] 1797 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1843:17
[INFO] [stdout]      |
[INFO] [stdout] 1843 | /                 bail_span!(
[INFO] [stdout] 1844 | |                     self,
[INFO] [stdout] 1845 | |                     "#[wasm_bindgen] can only be applied to a function, \
[INFO] [stdout] 1846 | |                      struct, enum, impl, or extern block",
[INFO] [stdout] 1847 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1858:13
[INFO] [stdout]      |
[INFO] [stdout] 1858 | /             bail_span!(
[INFO] [stdout] 1859 | |                 self.defaultness,
[INFO] [stdout] 1860 | |                 "#[wasm_bindgen] default impls are not supported"
[INFO] [stdout] 1861 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1864:13
[INFO] [stdout]      |
[INFO] [stdout] 1864 | /             bail_span!(
[INFO] [stdout] 1865 | |                 self.unsafety,
[INFO] [stdout] 1866 | |                 "#[wasm_bindgen] unsafe impls are not supported"
[INFO] [stdout] 1867 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1870:13
[INFO] [stdout]      |
[INFO] [stdout] 1870 |             bail_span!(path, "#[wasm_bindgen] trait impls are not supported");
[INFO] [stdout]      |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1873:13
[INFO] [stdout]      |
[INFO] [stdout] 1873 | /             bail_span!(
[INFO] [stdout] 1874 | |                 self.generics,
[INFO] [stdout] 1875 | |                 "#[wasm_bindgen] generic impls aren't supported"
[INFO] [stdout] 1876 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1883:18
[INFO] [stdout]      |
[INFO] [stdout] 1883 |               _ => bail_span!(
[INFO] [stdout]      |  __________________-
[INFO] [stdout] 1884 | |                 self.self_ty,
[INFO] [stdout] 1885 | |                 "unsupported self type in #[wasm_bindgen] impl"
[INFO] [stdout] 1886 | |             ),
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1917:13
[INFO] [stdout]      |
[INFO] [stdout] 1917 | /             bail_span!(
[INFO] [stdout] 1918 | |                 &*item,
[INFO] [stdout] 1919 | |                 "const definitions aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 1920 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1922:35
[INFO] [stdout]      |
[INFO] [stdout] 1922 |           syn::ImplItem::Type(_) => bail_span!(
[INFO] [stdout]      |  ___________________________________-
[INFO] [stdout] 1923 | |             &*item,
[INFO] [stdout] 1924 | |             "type definitions in impls aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 1925 | |         ),
[INFO] [stdout]      | |_________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1931:13
[INFO] [stdout]      |
[INFO] [stdout] 1931 |             bail_span!(&*item, "macros in impls aren't supported");
[INFO] [stdout]      |             ------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1934:18
[INFO] [stdout]      |
[INFO] [stdout] 1934 |         other => bail_span!(other, "failed to parse this item as a known item"),
[INFO] [stdout]      |                  -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2027:13
[INFO] [stdout]      |
[INFO] [stdout] 2027 | /             bail_span!(
[INFO] [stdout] 2028 | |                 self.sig.constness,
[INFO] [stdout] 2029 | |                 "can only #[wasm_bindgen] non-const functions",
[INFO] [stdout] 2030 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2036:13
[INFO] [stdout]      |
[INFO] [stdout] 2036 | /             bail_span!(
[INFO] [stdout] 2037 | |                 &self.sig.ident,
[INFO] [stdout] 2038 | |                 "#[wasm_bindgen(this)] cannot be used on impl block methods; \
[INFO] [stdout] 2039 | |                  it is only valid on free functions"
[INFO] [stdout] 2040 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2114:17
[INFO] [stdout]      |
[INFO] [stdout] 2114 |                 bail_span!(v, "all variants of a string enum must have a string value");
[INFO] [stdout]      |                 ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2125:21
[INFO] [stdout]      |
[INFO] [stdout] 2125 |               expr => bail_span!(
[INFO] [stdout]      |  _____________________-
[INFO] [stdout] 2126 | |                 expr,
[INFO] [stdout] 2127 | |                 "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2128 | |             ),
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2175:25
[INFO] [stdout]      |
[INFO] [stdout] 2175 | /                         bail_span!(
[INFO] [stdout] 2176 | |                             v,
[INFO] [stdout] 2177 | |                             "all unit variants of a string enum must have a string value"
[INFO] [stdout] 2178 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2190:29
[INFO] [stdout]      |
[INFO] [stdout] 2190 |                       expr => bail_span!(
[INFO] [stdout]      |  _____________________________-
[INFO] [stdout] 2191 | |                         expr,
[INFO] [stdout] 2192 | |                         "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2193 | |                     ),
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2204:17
[INFO] [stdout]      |
[INFO] [stdout] 2204 | /                 bail_span!(
[INFO] [stdout] 2205 | |                     v.fields,
[INFO] [stdout] 2206 | |                     "string enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2207 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2282:13
[INFO] [stdout]      |
[INFO] [stdout] 2282 |             bail_span!(self, "cannot export empty enums to JS");
[INFO] [stdout]      |             --------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2293:13
[INFO] [stdout]      |
[INFO] [stdout] 2293 | /             bail_span!(
[INFO] [stdout] 2294 | |                 self.ident,
[INFO] [stdout] 2295 | |                 "enum cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 2296 | |                 js_name
[INFO] [stdout] 2297 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2311:44
[INFO] [stdout]      |
[INFO] [stdout] 2311 |                   syn::Fields::Unnamed(_) => bail_span!(
[INFO] [stdout]      |  ____________________________________________-
[INFO] [stdout] 2312 | |                     variant.fields,
[INFO] [stdout] 2313 | |                     "enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2314 | |                 ),
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2316:21
[INFO] [stdout]      |
[INFO] [stdout] 2316 |                     bail_span!(variant.fields, "enum variants cannot have named fields")
[INFO] [stdout]      |                     -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2334:13
[INFO] [stdout]      |
[INFO] [stdout] 2334 | /             bail_span!(
[INFO] [stdout] 2335 | |                 self,
[INFO] [stdout] 2336 | |                 "the `fallback` attribute is only supported on dynamic unions \
[INFO] [stdout] 2337 | |                  (enums with at least one tuple variant)"
[INFO] [stdout] 2338 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2368:18
[INFO] [stdout]      |
[INFO] [stdout] 2368 |             _ => bail_span!(self, "only public enums are allowed with #[wasm_bindgen]"),
[INFO] [stdout]      |                  ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2396:30
[INFO] [stdout]      |
[INFO] [stdout] 2396 |                           _ => bail_span!(
[INFO] [stdout]      |  ______________________________-
[INFO] [stdout] 2397 | |                             expr,
[INFO] [stdout] 2398 | |                             "C-style enums with #[wasm_bindgen] may only have \
[INFO] [stdout] 2399 | |                              numeric literal values that fit in a 32-bit integer as discriminants. \
[INFO] [stdout] 2400 | |                              Expressions or variables are not supported.",
[INFO] [stdout] 2401 | |                         ),
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2416:21
[INFO] [stdout]      |
[INFO] [stdout] 2416 | /                     bail_span!(
[INFO] [stdout] 2417 | |                         v,
[INFO] [stdout] 2418 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2419 | |                         but `{1}` is too small for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2422 | |                         underlying
[INFO] [stdout] 2423 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2426:21
[INFO] [stdout]      |
[INFO] [stdout] 2426 | /                     bail_span!(
[INFO] [stdout] 2427 | |                         v,
[INFO] [stdout] 2428 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2429 | |                         but `{1}` is too large for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2432 | |                         underlying
[INFO] [stdout] 2433 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2438:21
[INFO] [stdout]      |
[INFO] [stdout] 2438 | /                     bail_span!(
[INFO] [stdout] 2439 | |                         v,
[INFO] [stdout] 2440 | |                         "discriminant value `{}` is already used by {} in this enum",
[INFO] [stdout] 2441 | |                         value,
[INFO] [stdout] 2442 | |                         old.ident
[INFO] [stdout] 2443 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2486:13
[INFO] [stdout]      |
[INFO] [stdout] 2486 | ...   bail_span!(self, "#[wasm_bindgen] will not work on constants unless you are defining a #[wasm_bindgen(typescript_custom_section)].");
[INFO] [stdout]      |       ------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2632:25
[INFO] [stdout]      |
[INFO] [stdout] 2632 | /                         bail_span!(
[INFO] [stdout] 2633 | |                             import_function.rust_name,
[INFO] [stdout] 2634 | |                             "Imported function cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2635 | |                             import_function.function.name
[INFO] [stdout] 2636 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2641:25
[INFO] [stdout]      |
[INFO] [stdout] 2641 | /                         bail_span!(
[INFO] [stdout] 2642 | |                             import_static.rust_name,
[INFO] [stdout] 2643 | |                             "Imported static cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2644 | |                             import_static.js_name
[INFO] [stdout] 2645 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2653:25
[INFO] [stdout]      |
[INFO] [stdout] 2653 | /                         bail_span!(
[INFO] [stdout] 2654 | |                             import_type.rust_name,
[INFO] [stdout] 2655 | |                             "Imported type cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2656 | |                             import_type.js_name
[INFO] [stdout] 2657 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2735:14
[INFO] [stdout]      |
[INFO] [stdout] 2735 |         _ => bail_span!(t, "must be Result<...>"),
[INFO] [stdout]      |              ------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2743:14
[INFO] [stdout]      |
[INFO] [stdout] 2743 |         _ => bail_span!(t, "must be Result<...>"),
[INFO] [stdout]      |              ------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2751:18
[INFO] [stdout]      |
[INFO] [stdout] 2751 |         other => bail_span!(other, "must be a type parameter"),
[INFO] [stdout]      |                  --------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2848:21
[INFO] [stdout]      |
[INFO] [stdout] 2848 | /                     bail_span!(
[INFO] [stdout] 2849 | |                         path,
[INFO] [stdout] 2850 | |                         "paths with type parameters are not supported in this position"
[INFO] [stdout] 2851 | |                     )
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2855:17
[INFO] [stdout]      |
[INFO] [stdout] 2855 |                 bail_span!(path, "parenthesized paths are not supported yet")
[INFO] [stdout]      |                 ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2863:13
[INFO] [stdout]      |
[INFO] [stdout] 2863 |             bail_span!(path, "empty idents are not supported");
[INFO] [stdout]      |             -------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2869:5
[INFO] [stdout]      |
[INFO] [stdout] 2869 |     bail_span!(span, "unsupported in wasm-bindgen generics");
[INFO] [stdout]      |     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3024:9
[INFO] [stdout]      |
[INFO] [stdout] 3024 |         bail_span!(&f.sig.ident, "the main function has to be called main");
[INFO] [stdout]      |         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3027:9
[INFO] [stdout]      |
[INFO] [stdout] 3027 |         bail_span!(&constness, "the main function cannot be const");
[INFO] [stdout]      |         ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3030:9
[INFO] [stdout]      |
[INFO] [stdout] 3030 |         bail_span!(&f.sig.generics, "the main function cannot have generics");
[INFO] [stdout]      |         --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3033:9
[INFO] [stdout]      |
[INFO] [stdout] 3033 |         bail_span!(&f.sig.inputs, "the main function cannot have arguments");
[INFO] [stdout]      |         -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `wasm-bindgen-macro-support-x` (lib test) due to 71 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/ast.rs:706:13
[INFO] [stdout]     |
[INFO] [stdout] 706 | /             bail_span!(
[INFO] [stdout] 707 | |                 syn::token::Pub(self.name_span),
[INFO] [stdout] 708 | |                 "setters must start with `set_`, found: {}",
[INFO] [stdout] 709 | |                 name,
[INFO] [stdout] 710 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::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: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/codegen.rs:868:13
[INFO] [stdout]     |
[INFO] [stdout] 868 |             bail_span!(syn_ret, "cannot return a borrowed ref with #[wasm_bindgen]",)
[INFO] [stdout]     |             ------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2112:22
[INFO] [stdout]      |
[INFO] [stdout] 2112 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 2113 | |                     arg.pat_type.pat,
[INFO] [stdout] 2114 | |                     "unsupported pattern in #[wasm_bindgen] imported function",
[INFO] [stdout] 2115 | |                 ),
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2279:17
[INFO] [stdout]      |
[INFO] [stdout] 2279 | /                 bail_span!(
[INFO] [stdout] 2280 | |                     self.js_ret,
[INFO] [stdout] 2281 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 2282 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/codegen.rs:2619:25
[INFO] [stdout]      |
[INFO] [stdout] 2619 |                         bail_span!(gen_arg, "Functions must provide generic arguments");
[INFO] [stdout]      |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:263:21
[INFO] [stdout]     |
[INFO] [stdout] 263 |                     bail_span!(attr, "malformed #[wasm_bindgen] attribute")
[INFO] [stdout]     |                     ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:555:13
[INFO] [stdout]     |
[INFO] [stdout] 555 | /             bail_span!(
[INFO] [stdout] 556 | |                 self.generics,
[INFO] [stdout] 557 | |                 "structs with #[wasm_bindgen] cannot have lifetime or \
[INFO] [stdout] 558 | |                  type parameters currently"
[INFO] [stdout] 559 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:632:13
[INFO] [stdout]     |
[INFO] [stdout] 632 | /             bail_span!(
[INFO] [stdout] 633 | |                 self.ident,
[INFO] [stdout] 634 | |                 "struct cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 635 | |                 js_name
[INFO] [stdout] 636 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:778:13
[INFO] [stdout]     |
[INFO] [stdout] 778 |             bail_span!(&field.ty, "{}", msg);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:789:17
[INFO] [stdout]     |
[INFO] [stdout] 789 | /                 bail_span!(
[INFO] [stdout] 790 | |                     ident,
[INFO] [stdout] 791 | |                     "struct with `#[wasm_bindgen(extends = ...)]` cannot \
[INFO] [stdout] 792 | |                      have a field named `parent`; the macro injects one"
[INFO] [stdout] 793 | |                 );
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:816:13
[INFO] [stdout]     |
[INFO] [stdout] 816 | /             bail_span!(
[INFO] [stdout] 817 | |                 &s.ident,
[INFO] [stdout] 818 | |                 "tuple structs cannot use `#[wasm_bindgen(extends = ...)]`; \
[INFO] [stdout] 819 | |                  use a named-field struct"
[INFO] [stdout] 820 | |             );
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 |   macro_rules! bail_span {
[INFO] [stdout]  14 |       ($($t:tt)*) => (
[INFO] [stdout]  15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:969:22
[INFO] [stdout]     |
[INFO] [stdout] 969 |                   _ => bail_span!(
[INFO] [stdout]     |  ______________________-
[INFO] [stdout] 970 | |                     class.pat_type.ty,
[INFO] [stdout] 971 | |                     "first argument of method must be a shared reference"
[INFO] [stdout] 972 | |                 ),
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]    --> src/error.rs:15:20
[INFO] [stdout]     |
[INFO] [stdout]  13 | macro_rules! bail_span {
[INFO] [stdout]  14 |     ($($t:tt)*) => (
[INFO] [stdout]  15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:986:22
[INFO] [stdout]     |
[INFO] [stdout] 986 |                 _ => bail_span!(class_ty, "first argument of method must be a path"),
[INFO] [stdout]     |                      --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1025:22
[INFO] [stdout]      |
[INFO] [stdout] 1025 |                 _ => bail_span!(self, "constructor returns must be bare types"),
[INFO] [stdout]      |                      ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1032:22
[INFO] [stdout]      |
[INFO] [stdout] 1032 |                 _ => bail_span!(self, "return value of constructor must be a bare path"),
[INFO] [stdout]      |                      ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1237:13
[INFO] [stdout]      |
[INFO] [stdout] 1237 |             bail_span!(self.mutability, "cannot import mutable globals yet")
[INFO] [stdout]      |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1280:13
[INFO] [stdout]      |
[INFO] [stdout] 1280 |             bail_span!(self.mutability, "cannot import mutable globals yet")
[INFO] [stdout]      |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1290:13
[INFO] [stdout]      |
[INFO] [stdout] 1290 | /             bail_span!(
[INFO] [stdout] 1291 | |                 self.expr,
[INFO] [stdout] 1292 | |                 "statics with a value can only be string literals"
[INFO] [stdout] 1293 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1297:13
[INFO] [stdout]      |
[INFO] [stdout] 1297 | /             bail_span!(
[INFO] [stdout] 1298 | |                 self,
[INFO] [stdout] 1299 | |                 "static strings require `#[wasm_bindgen(static_string)]`"
[INFO] [stdout] 1300 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1306:13
[INFO] [stdout]      |
[INFO] [stdout] 1306 | /             bail_span!(
[INFO] [stdout] 1307 | |                 self,
[INFO] [stdout] 1308 | |                 "static strings require `#[wasm_bindgen(thread_local_v2)]`"
[INFO] [stdout] 1309 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1339:18
[INFO] [stdout]      |
[INFO] [stdout] 1339 |             _ => bail_span!(self, "can only #[wasm_bindgen] public functions"),
[INFO] [stdout]      |                  ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1342:13
[INFO] [stdout]      |
[INFO] [stdout] 1342 | /             bail_span!(
[INFO] [stdout] 1343 | |                 self.sig.constness,
[INFO] [stdout] 1344 | |                 "can only #[wasm_bindgen] non-const functions"
[INFO] [stdout] 1345 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1408:9
[INFO] [stdout]      |
[INFO] [stdout] 1408 |         bail_span!(sig.variadic, "can't #[wasm_bindgen] variadic functions");
[INFO] [stdout]      |         -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1413:9
[INFO] [stdout]      |
[INFO] [stdout] 1413 | /         bail_span!(
[INFO] [stdout] 1414 | |             sig.generics,
[INFO] [stdout] 1415 | |             "can't #[wasm_bindgen] functions with lifetime or type parameters"
[INFO] [stdout] 1416 | |         );
[INFO] [stdout]      | |_________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1476:25
[INFO] [stdout]      |
[INFO] [stdout] 1476 | / ...   bail_span!(
[INFO] [stdout] 1477 | | ...       r.self_token,
[INFO] [stdout] 1478 | | ...       "the `self` argument is only allowed for functions in `impl` blocks.\n\n\
[INFO] [stdout] 1479 | | ...       If the function is already in an `impl` block, did you perhaps forget to add `#[wasm_bindgen]` to the `impl` block?"
[INFO] [stdout] 1480 | | ...   );
[INFO] [stdout]      | |_______- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1483:25
[INFO] [stdout]      |
[INFO] [stdout] 1483 | /                         bail_span!(
[INFO] [stdout] 1484 | |                             r.self_token,
[INFO] [stdout] 1485 | |                             "the `self` argument is not allowed for `extern` functions.\n\n\
[INFO] [stdout] 1486 | |                             Did you perhaps mean `this`? For more information on importing JavaScript functions, see:\n\
[INFO] [stdout] 1487 | |                             https://wasm-bindgen.github.io/wasm-bindgen/examples/import-js.html"
[INFO] [stdout] 1488 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1772:25
[INFO] [stdout]      |
[INFO] [stdout] 1772 |                         bail_span!(&f.sig.generics, "the start function cannot have generics",);
[INFO] [stdout]      |                         ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1775:25
[INFO] [stdout]      |
[INFO] [stdout] 1775 |                         bail_span!(&f.sig.inputs, "the start function cannot have arguments",);
[INFO] [stdout]      |                         ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1794:21
[INFO] [stdout]      |
[INFO] [stdout] 1794 | /                     bail_span!(
[INFO] [stdout] 1795 | |                         &f.sig.inputs,
[INFO] [stdout] 1796 | |                         "functions taking a 'this' argument must have at least one parameter"
[INFO] [stdout] 1797 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1843:17
[INFO] [stdout]      |
[INFO] [stdout] 1843 | /                 bail_span!(
[INFO] [stdout] 1844 | |                     self,
[INFO] [stdout] 1845 | |                     "#[wasm_bindgen] can only be applied to a function, \
[INFO] [stdout] 1846 | |                      struct, enum, impl, or extern block",
[INFO] [stdout] 1847 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1858:13
[INFO] [stdout]      |
[INFO] [stdout] 1858 | /             bail_span!(
[INFO] [stdout] 1859 | |                 self.defaultness,
[INFO] [stdout] 1860 | |                 "#[wasm_bindgen] default impls are not supported"
[INFO] [stdout] 1861 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1864:13
[INFO] [stdout]      |
[INFO] [stdout] 1864 | /             bail_span!(
[INFO] [stdout] 1865 | |                 self.unsafety,
[INFO] [stdout] 1866 | |                 "#[wasm_bindgen] unsafe impls are not supported"
[INFO] [stdout] 1867 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1870:13
[INFO] [stdout]      |
[INFO] [stdout] 1870 |             bail_span!(path, "#[wasm_bindgen] trait impls are not supported");
[INFO] [stdout]      |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1873:13
[INFO] [stdout]      |
[INFO] [stdout] 1873 | /             bail_span!(
[INFO] [stdout] 1874 | |                 self.generics,
[INFO] [stdout] 1875 | |                 "#[wasm_bindgen] generic impls aren't supported"
[INFO] [stdout] 1876 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1883:18
[INFO] [stdout]      |
[INFO] [stdout] 1883 |               _ => bail_span!(
[INFO] [stdout]      |  __________________-
[INFO] [stdout] 1884 | |                 self.self_ty,
[INFO] [stdout] 1885 | |                 "unsupported self type in #[wasm_bindgen] impl"
[INFO] [stdout] 1886 | |             ),
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1917:13
[INFO] [stdout]      |
[INFO] [stdout] 1917 | /             bail_span!(
[INFO] [stdout] 1918 | |                 &*item,
[INFO] [stdout] 1919 | |                 "const definitions aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 1920 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1922:35
[INFO] [stdout]      |
[INFO] [stdout] 1922 |           syn::ImplItem::Type(_) => bail_span!(
[INFO] [stdout]      |  ___________________________________-
[INFO] [stdout] 1923 | |             &*item,
[INFO] [stdout] 1924 | |             "type definitions in impls aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 1925 | |         ),
[INFO] [stdout]      | |_________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1931:13
[INFO] [stdout]      |
[INFO] [stdout] 1931 |             bail_span!(&*item, "macros in impls aren't supported");
[INFO] [stdout]      |             ------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:1934:18
[INFO] [stdout]      |
[INFO] [stdout] 1934 |         other => bail_span!(other, "failed to parse this item as a known item"),
[INFO] [stdout]      |                  -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2027:13
[INFO] [stdout]      |
[INFO] [stdout] 2027 | /             bail_span!(
[INFO] [stdout] 2028 | |                 self.sig.constness,
[INFO] [stdout] 2029 | |                 "can only #[wasm_bindgen] non-const functions",
[INFO] [stdout] 2030 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2036:13
[INFO] [stdout]      |
[INFO] [stdout] 2036 | /             bail_span!(
[INFO] [stdout] 2037 | |                 &self.sig.ident,
[INFO] [stdout] 2038 | |                 "#[wasm_bindgen(this)] cannot be used on impl block methods; \
[INFO] [stdout] 2039 | |                  it is only valid on free functions"
[INFO] [stdout] 2040 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2114:17
[INFO] [stdout]      |
[INFO] [stdout] 2114 |                 bail_span!(v, "all variants of a string enum must have a string value");
[INFO] [stdout]      |                 ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2125:21
[INFO] [stdout]      |
[INFO] [stdout] 2125 |               expr => bail_span!(
[INFO] [stdout]      |  _____________________-
[INFO] [stdout] 2126 | |                 expr,
[INFO] [stdout] 2127 | |                 "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2128 | |             ),
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2175:25
[INFO] [stdout]      |
[INFO] [stdout] 2175 | /                         bail_span!(
[INFO] [stdout] 2176 | |                             v,
[INFO] [stdout] 2177 | |                             "all unit variants of a string enum must have a string value"
[INFO] [stdout] 2178 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2190:29
[INFO] [stdout]      |
[INFO] [stdout] 2190 |                       expr => bail_span!(
[INFO] [stdout]      |  _____________________________-
[INFO] [stdout] 2191 | |                         expr,
[INFO] [stdout] 2192 | |                         "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2193 | |                     ),
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2204:17
[INFO] [stdout]      |
[INFO] [stdout] 2204 | /                 bail_span!(
[INFO] [stdout] 2205 | |                     v.fields,
[INFO] [stdout] 2206 | |                     "string enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2207 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2282:13
[INFO] [stdout]      |
[INFO] [stdout] 2282 |             bail_span!(self, "cannot export empty enums to JS");
[INFO] [stdout]      |             --------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2293:13
[INFO] [stdout]      |
[INFO] [stdout] 2293 | /             bail_span!(
[INFO] [stdout] 2294 | |                 self.ident,
[INFO] [stdout] 2295 | |                 "enum cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 2296 | |                 js_name
[INFO] [stdout] 2297 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2311:44
[INFO] [stdout]      |
[INFO] [stdout] 2311 |                   syn::Fields::Unnamed(_) => bail_span!(
[INFO] [stdout]      |  ____________________________________________-
[INFO] [stdout] 2312 | |                     variant.fields,
[INFO] [stdout] 2313 | |                     "enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2314 | |                 ),
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2316:21
[INFO] [stdout]      |
[INFO] [stdout] 2316 |                     bail_span!(variant.fields, "enum variants cannot have named fields")
[INFO] [stdout]      |                     -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2334:13
[INFO] [stdout]      |
[INFO] [stdout] 2334 | /             bail_span!(
[INFO] [stdout] 2335 | |                 self,
[INFO] [stdout] 2336 | |                 "the `fallback` attribute is only supported on dynamic unions \
[INFO] [stdout] 2337 | |                  (enums with at least one tuple variant)"
[INFO] [stdout] 2338 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2368:18
[INFO] [stdout]      |
[INFO] [stdout] 2368 |             _ => bail_span!(self, "only public enums are allowed with #[wasm_bindgen]"),
[INFO] [stdout]      |                  ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2396:30
[INFO] [stdout]      |
[INFO] [stdout] 2396 |                           _ => bail_span!(
[INFO] [stdout]      |  ______________________________-
[INFO] [stdout] 2397 | |                             expr,
[INFO] [stdout] 2398 | |                             "C-style enums with #[wasm_bindgen] may only have \
[INFO] [stdout] 2399 | |                              numeric literal values that fit in a 32-bit integer as discriminants. \
[INFO] [stdout] 2400 | |                              Expressions or variables are not supported.",
[INFO] [stdout] 2401 | |                         ),
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2416:21
[INFO] [stdout]      |
[INFO] [stdout] 2416 | /                     bail_span!(
[INFO] [stdout] 2417 | |                         v,
[INFO] [stdout] 2418 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2419 | |                         but `{1}` is too small for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2422 | |                         underlying
[INFO] [stdout] 2423 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2426:21
[INFO] [stdout]      |
[INFO] [stdout] 2426 | /                     bail_span!(
[INFO] [stdout] 2427 | |                         v,
[INFO] [stdout] 2428 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2429 | |                         but `{1}` is too large for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2432 | |                         underlying
[INFO] [stdout] 2433 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2438:21
[INFO] [stdout]      |
[INFO] [stdout] 2438 | /                     bail_span!(
[INFO] [stdout] 2439 | |                         v,
[INFO] [stdout] 2440 | |                         "discriminant value `{}` is already used by {} in this enum",
[INFO] [stdout] 2441 | |                         value,
[INFO] [stdout] 2442 | |                         old.ident
[INFO] [stdout] 2443 | |                     );
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2486:13
[INFO] [stdout]      |
[INFO] [stdout] 2486 | ...   bail_span!(self, "#[wasm_bindgen] will not work on constants unless you are defining a #[wasm_bindgen(typescript_custom_section)].");
[INFO] [stdout]      |       ------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2632:25
[INFO] [stdout]      |
[INFO] [stdout] 2632 | /                         bail_span!(
[INFO] [stdout] 2633 | |                             import_function.rust_name,
[INFO] [stdout] 2634 | |                             "Imported function cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2635 | |                             import_function.function.name
[INFO] [stdout] 2636 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2641:25
[INFO] [stdout]      |
[INFO] [stdout] 2641 | /                         bail_span!(
[INFO] [stdout] 2642 | |                             import_static.rust_name,
[INFO] [stdout] 2643 | |                             "Imported static cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2644 | |                             import_static.js_name
[INFO] [stdout] 2645 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2653:25
[INFO] [stdout]      |
[INFO] [stdout] 2653 | /                         bail_span!(
[INFO] [stdout] 2654 | |                             import_type.rust_name,
[INFO] [stdout] 2655 | |                             "Imported type cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 2656 | |                             import_type.js_name
[INFO] [stdout] 2657 | |                         );
[INFO] [stdout]      | |_________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2735:14
[INFO] [stdout]      |
[INFO] [stdout] 2735 |         _ => bail_span!(t, "must be Result<...>"),
[INFO] [stdout]      |              ------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2743:14
[INFO] [stdout]      |
[INFO] [stdout] 2743 |         _ => bail_span!(t, "must be Result<...>"),
[INFO] [stdout]      |              ------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2751:18
[INFO] [stdout]      |
[INFO] [stdout] 2751 |         other => bail_span!(other, "must be a type parameter"),
[INFO] [stdout]      |                  --------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 |   macro_rules! bail_span {
[INFO] [stdout]   14 |       ($($t:tt)*) => (
[INFO] [stdout]   15 |           return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2848:21
[INFO] [stdout]      |
[INFO] [stdout] 2848 | /                     bail_span!(
[INFO] [stdout] 2849 | |                         path,
[INFO] [stdout] 2850 | |                         "paths with type parameters are not supported in this position"
[INFO] [stdout] 2851 | |                     )
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2855:17
[INFO] [stdout]      |
[INFO] [stdout] 2855 |                 bail_span!(path, "parenthesized paths are not supported yet")
[INFO] [stdout]      |                 ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2863:13
[INFO] [stdout]      |
[INFO] [stdout] 2863 |             bail_span!(path, "empty idents are not supported");
[INFO] [stdout]      |             -------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:2869:5
[INFO] [stdout]      |
[INFO] [stdout] 2869 |     bail_span!(span, "unsupported in wasm-bindgen generics");
[INFO] [stdout]      |     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3024:9
[INFO] [stdout]      |
[INFO] [stdout] 3024 |         bail_span!(&f.sig.ident, "the main function has to be called main");
[INFO] [stdout]      |         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3027:9
[INFO] [stdout]      |
[INFO] [stdout] 3027 |         bail_span!(&constness, "the main function cannot be const");
[INFO] [stdout]      |         ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3030:9
[INFO] [stdout]      |
[INFO] [stdout] 3030 |         bail_span!(&f.sig.generics, "the main function cannot have generics");
[INFO] [stdout]      |         --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Diagnostic`
[INFO] [stdout]     --> src/error.rs:15:20
[INFO] [stdout]      |
[INFO] [stdout]   13 | macro_rules! bail_span {
[INFO] [stdout]   14 |     ($($t:tt)*) => (
[INFO] [stdout]   15 |         return Err(err_span!($($t)*).into())
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/parser.rs:3033:9
[INFO] [stdout]      |
[INFO] [stdout] 3033 |         bail_span!(&f.sig.inputs, "the main function cannot have arguments");
[INFO] [stdout]      |         -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<Diagnostic as Into<Diagnostic>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `wasm-bindgen-macro-support-x` (lib) due to 71 previous errors
[INFO] running `Command { std: "docker" "inspect" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce", kill_on_drop: false }`
[INFO] [stdout] 6eb607899085dc523b441658af922a96b00493e454d5e246f477ce439937c0ce
