[INFO] fetching crate wasm-bindgen-macro-support 0.2.129...
[INFO] checking wasm-bindgen-macro-support-0.2.129 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate wasm-bindgen-macro-support 0.2.129 into /workspace/builds/worker-3-tc2/source
[INFO] started tweaking crates.io crate wasm-bindgen-macro-support 0.2.129
[INFO] finished tweaking crates.io crate wasm-bindgen-macro-support 0.2.129
[INFO] tweaked toml for crates.io crate wasm-bindgen-macro-support 0.2.129 written to /workspace/builds/worker-3-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate wasm-bindgen-macro-support 0.2.129 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 0.2.129 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487
[INFO] running `Command { std: "docker" "start" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487", 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" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487", 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" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking unicode-ident v1.0.26
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling wasm-bindgen-shared v0.2.129
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]     Checking quote v1.0.47
[INFO] [stderr]     Checking syn v3.0.6
[INFO] [stderr]     Checking wasm-bindgen-macro-support v0.2.129 (/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:736:13
[INFO] [stdout]     |
[INFO] [stdout] 736 | /             bail_span!(
[INFO] [stdout] 737 | |                 syn::token::Pub(self.name_span),
[INFO] [stdout] 738 | |                 "setters must start with `set_`, found: {}",
[INFO] [stdout] 739 | |                 name,
[INFO] [stdout] 740 | |             );
[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:1079:13
[INFO] [stdout]      |
[INFO] [stdout] 1079 |             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:2523:22
[INFO] [stdout]      |
[INFO] [stdout] 2523 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 2524 | |                     arg.pat_type.pat,
[INFO] [stdout] 2525 | |                     "unsupported pattern in #[wasm_bindgen] imported function",
[INFO] [stdout] 2526 | |                 ),
[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:2659:17
[INFO] [stdout]      |
[INFO] [stdout] 2659 | /                 bail_span!(
[INFO] [stdout] 2660 | |                     self.js_ret,
[INFO] [stdout] 2661 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 2662 | |                 );
[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:3140:13
[INFO] [stdout]      |
[INFO] [stdout] 3140 | /             bail_span!(
[INFO] [stdout] 3141 | |                 self.rust_name,
[INFO] [stdout] 3142 | |                 "experimental_generic_mono requires at least one type parameter"
[INFO] [stdout] 3143 | |             );
[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:3159:17
[INFO] [stdout]      |
[INFO] [stdout] 3159 | /                 bail_span!(
[INFO] [stdout] 3160 | |                     type_param,
[INFO] [stdout] 3161 | |                     "defaults for generic parameters are not allowed here"
[INFO] [stdout] 3162 | |                 );
[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:3256:25
[INFO] [stdout]      |
[INFO] [stdout] 3256 | / ...   bail_span!(
[INFO] [stdout] 3257 | | ...       class,
[INFO] [stdout] 3258 | | ...       "experimental_generic_mono requires static methods on imported classes with required generic parameters to write those...
[INFO] [stdout] 3259 | | ...   );
[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:3289:21
[INFO] [stdout]      |
[INFO] [stdout] 3289 | /                     bail_span!(
[INFO] [stdout] 3290 | |                         ty,
[INFO] [stdout] 3291 | |                         "experimental_generic_mono requires the `variadic` argument to be a sequence when \
[INFO] [stdout] 3292 | |                          it mentions a type parameter, because it is spread with `...` on the JS \
[INFO] [stdout] 3293 | |                          side and must be iterable for every monomorphisation; use `Vec<T>`, \
[INFO] [stdout] 3294 | |                          `[T; N]` or `&[T]`, or the type-erasure generic path instead"
[INFO] [stdout] 3295 | |                     );
[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:3313:21
[INFO] [stdout]      |
[INFO] [stdout] 3313 | /                     bail_span!(
[INFO] [stdout] 3314 | |                         err_ty,
[INFO] [stdout] 3315 | |                         "the error type of a `catch` import must be `JsValue`, not a type \
[INFO] [stdout] 3316 | |                          parameter; only the `Ok` type is monomorphised"
[INFO] [stdout] 3317 | |                     );
[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:3376:22
[INFO] [stdout]      |
[INFO] [stdout] 3376 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 3377 | |                     arg.pat_type.pat,
[INFO] [stdout] 3378 | |                     "unsupported pattern in experimental_generic_mono imported function",
[INFO] [stdout] 3379 | |                 ),
[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:3388:25
[INFO] [stdout]      |
[INFO] [stdout] 3388 | /                         bail_span!(
[INFO] [stdout] 3389 | |                             ty,
[INFO] [stdout] 3390 | |                             "experimental_generic_mono does not support higher-ranked generic callback signatures"
[INFO] [stdout] 3391 | |                         );
[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:3396:33
[INFO] [stdout]      |
[INFO] [stdout] 3396 | / ...                   bail_span!(
[INFO] [stdout] 3397 | | ...                       input,
[INFO] [stdout] 3398 | | ...                       "experimental_generic_mono does not support borrowed generic callback arguments"
[INFO] [stdout] 3399 | | ...                   );
[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:3408:29
[INFO] [stdout]      |
[INFO] [stdout] 3408 | / ...                   bail_span!(
[INFO] [stdout] 3409 | | ...                       ret,
[INFO] [stdout] 3410 | | ...                       "experimental_generic_mono does not support borrowed generic callback returns"
[INFO] [stdout] 3411 | | ...                   );
[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:3474:21
[INFO] [stdout]      |
[INFO] [stdout] 3474 | /                     bail_span!(
[INFO] [stdout] 3475 | |                         ty,
[INFO] [stdout] 3476 | |                         "experimental_generic_mono only supports a bare shared reference to a generic \
[INFO] [stdout] 3477 | |                          type parameter (`&T`); mutable references (`&mut T`) and references \
[INFO] [stdout] 3478 | |                          nested inside another type (e.g. `Option<&T>`) are not supported — \
[INFO] [stdout] 3479 | |                          take the argument by value or use the type-erasure generic path"
[INFO] [stdout] 3480 | |                     );
[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:3555:17
[INFO] [stdout]      |
[INFO] [stdout] 3555 | /                 bail_span!(
[INFO] [stdout] 3556 | |                     self.js_ret,
[INFO] [stdout] 3557 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 3558 | |                 );
[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:4175:21
[INFO] [stdout]      |
[INFO] [stdout] 4175 | / ...   bail_span!(
[INFO] [stdout] 4176 | | ...       segment,
[INFO] [stdout] 4177 | | ...       "imported classes with lifetime parameters require explicit lifetime arguments on generated impls; name the lifetime a...
[INFO] [stdout] 4178 | | ...   );
[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:4188:25
[INFO] [stdout]      |
[INFO] [stdout] 4188 | /                         bail_span!(
[INFO] [stdout] 4189 | |                             class,
[INFO] [stdout] 4190 | |                             "wasm-bindgen cannot substitute a projected imported-type default for a non-path class argument"
[INFO] [stdout] 4191 | |                         );
[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:4210:17
[INFO] [stdout]      |
[INFO] [stdout] 4210 | /                 bail_span!(
[INFO] [stdout] 4211 | |                     class,
[INFO] [stdout] 4212 | |                     "an imported-class bound conflicts with a function lifetime of the same name"
[INFO] [stdout] 4213 | |                 );
[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:4216:17
[INFO] [stdout]      |
[INFO] [stdout] 4216 | /                 bail_span!(
[INFO] [stdout] 4217 | |                     class,
[INFO] [stdout] 4218 | |                     "wasm-bindgen cannot substitute an imported-type bound that projects a non-path class argument"
[INFO] [stdout] 4219 | |                 );
[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:4386:25
[INFO] [stdout]      |
[INFO] [stdout] 4386 |                         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/codegen.rs:4674:21
[INFO] [stdout]      |
[INFO] [stdout] 4674 | /                     bail_span!(
[INFO] [stdout] 4675 | |                         lt,
[INFO] [stdout] 4676 | |                         "wasm-bindgen does not support a lifetime argument on the class type \
[INFO] [stdout] 4677 | |                          that the function does not itself declare; name it as a lifetime \
[INFO] [stdout] 4678 | |                          parameter of the function (e.g. `fn f<'a, T>(this: &'a Holder<'a, T>)`)"
[INFO] [stdout] 4679 | |                     );
[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:4684:21
[INFO] [stdout]      |
[INFO] [stdout] 4684 | / ...   bail_span!(
[INFO] [stdout] 4685 | | ...       ty,
[INFO] [stdout] 4686 | | ...       "wasm-bindgen does not support elided lifetimes in class type arguments; name the lifetime as a function parameter"
[INFO] [stdout] 4687 | | ...   );
[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:4690:21
[INFO] [stdout]      |
[INFO] [stdout] 4690 | / ...   bail_span!(
[INFO] [stdout] 4691 | | ...       ty,
[INFO] [stdout] 4692 | | ...       "wasm-bindgen does not support inferred (`_`) class type arguments; use a concrete type or named function type parameter"
[INFO] [stdout] 4693 | | ...   );
[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:4698:21
[INFO] [stdout]      |
[INFO] [stdout] 4698 | / ...   bail_span!(
[INFO] [stdout] 4699 | | ...       ty,
[INFO] [stdout] 4700 | | ...       "wasm-bindgen does not support `impl Trait` in class type arguments; name it as a function type parameter (e.g. `fn f<...
[INFO] [stdout] 4701 | | ...   );
[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:4746:13
[INFO] [stdout]      |
[INFO] [stdout] 4746 | /             bail_span!(
[INFO] [stdout] 4747 | |                 self.rust_name,
[INFO] [stdout] 4748 | |                 "wasm-bindgen requires each generic argument of an impl class type to be either \
[INFO] [stdout] 4749 | |                  concrete or to determine a generic parameter of the function (e.g. \
[INFO] [stdout] ...    |
[INFO] [stdout] 4752 | |                  block cannot constrain it"
[INFO] [stdout] 4753 | |             );
[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:4887:13
[INFO] [stdout]      |
[INFO] [stdout] 4887 | / ...   bail_span!(
[INFO] [stdout] 4888 | | ...       ret_ty,
[INFO] [stdout] 4889 | | ...       "experimental_generic_mono cannot use a constructor or self-returning static method whose class return mixes a lifetim...
[INFO] [stdout] 4890 | | ...   );
[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:273:21
[INFO] [stdout]     |
[INFO] [stdout] 273 |                     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:580:13
[INFO] [stdout]     |
[INFO] [stdout] 580 | /             bail_span!(
[INFO] [stdout] 581 | |                 self.generics,
[INFO] [stdout] 582 | |                 "structs with #[wasm_bindgen] cannot have lifetime or \
[INFO] [stdout] 583 | |                  type parameters currently"
[INFO] [stdout] 584 | |             );
[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:657:13
[INFO] [stdout]     |
[INFO] [stdout] 657 | /             bail_span!(
[INFO] [stdout] 658 | |                 self.ident,
[INFO] [stdout] 659 | |                 "struct cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 660 | |                 js_name
[INFO] [stdout] 661 | |             );
[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:803:13
[INFO] [stdout]     |
[INFO] [stdout] 803 |             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:814:17
[INFO] [stdout]     |
[INFO] [stdout] 814 | /                 bail_span!(
[INFO] [stdout] 815 | |                     ident,
[INFO] [stdout] 816 | |                     "struct with `#[wasm_bindgen(extends = ...)]` cannot \
[INFO] [stdout] 817 | |                      have a field named `parent`; the macro injects one"
[INFO] [stdout] 818 | |                 );
[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:841:13
[INFO] [stdout]     |
[INFO] [stdout] 841 | /             bail_span!(
[INFO] [stdout] 842 | |                 &s.ident,
[INFO] [stdout] 843 | |                 "tuple structs cannot use `#[wasm_bindgen(extends = ...)]`; \
[INFO] [stdout] 844 | |                  use a named-field struct"
[INFO] [stdout] 845 | |             );
[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:998:22
[INFO] [stdout]      |
[INFO] [stdout]  998 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout]  999 | |                     class.pat_type.ty,
[INFO] [stdout] 1000 | |                     "first argument of method must be a shared reference"
[INFO] [stdout] 1001 | |                 ),
[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:1016:22
[INFO] [stdout]      |
[INFO] [stdout] 1016 |                 _ => 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:1030:17
[INFO] [stdout]      |
[INFO] [stdout] 1030 | /                 bail_span!(
[INFO] [stdout] 1031 | |                     cls,
[INFO] [stdout] 1032 | |                     "static_method_of does not support qualified-self projections"
[INFO] [stdout] 1033 | |                 );
[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:1051:22
[INFO] [stdout]      |
[INFO] [stdout] 1051 |                 _ => 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:1059:22
[INFO] [stdout]      |
[INFO] [stdout] 1059 |                 _ => 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:1381:13
[INFO] [stdout]      |
[INFO] [stdout] 1381 |             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:1429:13
[INFO] [stdout]      |
[INFO] [stdout] 1429 |             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:1439:13
[INFO] [stdout]      |
[INFO] [stdout] 1439 | /             bail_span!(
[INFO] [stdout] 1440 | |                 self.expr,
[INFO] [stdout] 1441 | |                 "statics with a value can only be string literals"
[INFO] [stdout] 1442 | |             )
[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:1446:13
[INFO] [stdout]      |
[INFO] [stdout] 1446 | /             bail_span!(
[INFO] [stdout] 1447 | |                 self,
[INFO] [stdout] 1448 | |                 "static strings require `#[wasm_bindgen(static_string)]`"
[INFO] [stdout] 1449 | |             )
[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:1455:13
[INFO] [stdout]      |
[INFO] [stdout] 1455 | /             bail_span!(
[INFO] [stdout] 1456 | |                 self,
[INFO] [stdout] 1457 | |                 "static strings require `#[wasm_bindgen(thread_local_v2)]`"
[INFO] [stdout] 1458 | |             )
[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:1488:18
[INFO] [stdout]      |
[INFO] [stdout] 1488 |             _ => 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:1491:13
[INFO] [stdout]      |
[INFO] [stdout] 1491 | /             bail_span!(
[INFO] [stdout] 1492 | |                 self.sig.constness,
[INFO] [stdout] 1493 | |                 "can only #[wasm_bindgen] non-const functions"
[INFO] [stdout] 1494 | |             );
[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:1566:9
[INFO] [stdout]      |
[INFO] [stdout] 1566 |         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:1571:9
[INFO] [stdout]      |
[INFO] [stdout] 1571 | /         bail_span!(
[INFO] [stdout] 1572 | |             sig.generics,
[INFO] [stdout] 1573 | |             "can't #[wasm_bindgen] functions with lifetime or type parameters"
[INFO] [stdout] 1574 | |         );
[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:1634:25
[INFO] [stdout]      |
[INFO] [stdout] 1634 | / ...   bail_span!(
[INFO] [stdout] 1635 | | ...       r.self_token,
[INFO] [stdout] 1636 | | ...       "the `self` argument is only allowed for functions in `impl` blocks.\n\n\
[INFO] [stdout] 1637 | | ...       If the function is already in an `impl` block, did you perhaps forget to add `#[wasm_bindgen]` to the `impl` block?"
[INFO] [stdout] 1638 | | ...   );
[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:1641:25
[INFO] [stdout]      |
[INFO] [stdout] 1641 | /                         bail_span!(
[INFO] [stdout] 1642 | |                             r.self_token,
[INFO] [stdout] 1643 | |                             "the `self` argument is not allowed for `extern` functions.\n\n\
[INFO] [stdout] 1644 | |                             Did you perhaps mean `this`? For more information on importing JavaScript functions, see:\n\
[INFO] [stdout] 1645 | |                             https://wasm-bindgen.github.io/wasm-bindgen/examples/import-js.html"
[INFO] [stdout] 1646 | |                         );
[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:2022:25
[INFO] [stdout]      |
[INFO] [stdout] 2022 |                         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:2025:25
[INFO] [stdout]      |
[INFO] [stdout] 2025 |                         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:2044:21
[INFO] [stdout]      |
[INFO] [stdout] 2044 | /                     bail_span!(
[INFO] [stdout] 2045 | |                         &f.sig.inputs,
[INFO] [stdout] 2046 | |                         "functions taking a 'this' argument must have at least one parameter"
[INFO] [stdout] 2047 | |                     );
[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:2104:17
[INFO] [stdout]      |
[INFO] [stdout] 2104 | /                 bail_span!(
[INFO] [stdout] 2105 | |                     self,
[INFO] [stdout] 2106 | |                     "#[wasm_bindgen] can only be applied to a function, \
[INFO] [stdout] 2107 | |                      struct, enum, impl, or extern block",
[INFO] [stdout] 2108 | |                 );
[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:2119:13
[INFO] [stdout]      |
[INFO] [stdout] 2119 | /             bail_span!(
[INFO] [stdout] 2120 | |                 self.modifiers.defaultness,
[INFO] [stdout] 2121 | |                 "#[wasm_bindgen] default impls are not supported"
[INFO] [stdout] 2122 | |             );
[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:13
[INFO] [stdout]      |
[INFO] [stdout] 2125 | /             bail_span!(
[INFO] [stdout] 2126 | |                 self.unsafety,
[INFO] [stdout] 2127 | |                 "#[wasm_bindgen] unsafe impls are not supported"
[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:2131:13
[INFO] [stdout]      |
[INFO] [stdout] 2131 |             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:2134:13
[INFO] [stdout]      |
[INFO] [stdout] 2134 | /             bail_span!(
[INFO] [stdout] 2135 | |                 self.generics,
[INFO] [stdout] 2136 | |                 "#[wasm_bindgen] generic impls aren't supported"
[INFO] [stdout] 2137 | |             );
[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:2145:18
[INFO] [stdout]      |
[INFO] [stdout] 2145 |               _ => bail_span!(
[INFO] [stdout]      |  __________________-
[INFO] [stdout] 2146 | |                 self.self_ty,
[INFO] [stdout] 2147 | |                 "unsupported self type in #[wasm_bindgen] impl"
[INFO] [stdout] 2148 | |             ),
[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:2179:13
[INFO] [stdout]      |
[INFO] [stdout] 2179 | /             bail_span!(
[INFO] [stdout] 2180 | |                 &*item,
[INFO] [stdout] 2181 | |                 "const definitions aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 2182 | |             );
[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:2184:35
[INFO] [stdout]      |
[INFO] [stdout] 2184 |           syn::ImplItem::Type(_) => bail_span!(
[INFO] [stdout]      |  ___________________________________-
[INFO] [stdout] 2185 | |             &*item,
[INFO] [stdout] 2186 | |             "type definitions in impls aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 2187 | |         ),
[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:2193:13
[INFO] [stdout]      |
[INFO] [stdout] 2193 |             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:2196:18
[INFO] [stdout]      |
[INFO] [stdout] 2196 |         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:2289:13
[INFO] [stdout]      |
[INFO] [stdout] 2289 | /             bail_span!(
[INFO] [stdout] 2290 | |                 self.sig.constness,
[INFO] [stdout] 2291 | |                 "can only #[wasm_bindgen] non-const functions",
[INFO] [stdout] 2292 | |             );
[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:2298:13
[INFO] [stdout]      |
[INFO] [stdout] 2298 | /             bail_span!(
[INFO] [stdout] 2299 | |                 &self.sig.ident,
[INFO] [stdout] 2300 | |                 "#[wasm_bindgen(this)] cannot be used on impl block methods; \
[INFO] [stdout] 2301 | |                  it is only valid on free functions"
[INFO] [stdout] 2302 | |             );
[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:2404:17
[INFO] [stdout]      |
[INFO] [stdout] 2404 |                 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:2415:21
[INFO] [stdout]      |
[INFO] [stdout] 2415 |               expr => bail_span!(
[INFO] [stdout]      |  _____________________-
[INFO] [stdout] 2416 | |                 expr,
[INFO] [stdout] 2417 | |                 "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2418 | |             ),
[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:2465:25
[INFO] [stdout]      |
[INFO] [stdout] 2465 | /                         bail_span!(
[INFO] [stdout] 2466 | |                             v,
[INFO] [stdout] 2467 | |                             "all unit variants of a string enum must have a string value"
[INFO] [stdout] 2468 | |                         );
[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:2480:29
[INFO] [stdout]      |
[INFO] [stdout] 2480 |                       expr => bail_span!(
[INFO] [stdout]      |  _____________________________-
[INFO] [stdout] 2481 | |                         expr,
[INFO] [stdout] 2482 | |                         "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2483 | |                     ),
[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:2494:17
[INFO] [stdout]      |
[INFO] [stdout] 2494 | /                 bail_span!(
[INFO] [stdout] 2495 | |                     v.fields,
[INFO] [stdout] 2496 | |                     "string enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2497 | |                 );
[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:2572:13
[INFO] [stdout]      |
[INFO] [stdout] 2572 |             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:2583:13
[INFO] [stdout]      |
[INFO] [stdout] 2583 | /             bail_span!(
[INFO] [stdout] 2584 | |                 self.ident,
[INFO] [stdout] 2585 | |                 "enum cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 2586 | |                 js_name
[INFO] [stdout] 2587 | |             );
[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:2601:44
[INFO] [stdout]      |
[INFO] [stdout] 2601 |                   syn::Fields::Unnamed(_) => bail_span!(
[INFO] [stdout]      |  ____________________________________________-
[INFO] [stdout] 2602 | |                     variant.fields,
[INFO] [stdout] 2603 | |                     "enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2604 | |                 ),
[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:2606:21
[INFO] [stdout]      |
[INFO] [stdout] 2606 |                     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:2624:13
[INFO] [stdout]      |
[INFO] [stdout] 2624 | /             bail_span!(
[INFO] [stdout] 2625 | |                 self,
[INFO] [stdout] 2626 | |                 "the `fallback` attribute is only supported on dynamic unions \
[INFO] [stdout] 2627 | |                  (enums with at least one tuple variant)"
[INFO] [stdout] 2628 | |             );
[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:2658:18
[INFO] [stdout]      |
[INFO] [stdout] 2658 |             _ => 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:2686:30
[INFO] [stdout]      |
[INFO] [stdout] 2686 |                           _ => bail_span!(
[INFO] [stdout]      |  ______________________________-
[INFO] [stdout] 2687 | |                             expr,
[INFO] [stdout] 2688 | |                             "C-style enums with #[wasm_bindgen] may only have \
[INFO] [stdout] 2689 | |                              numeric literal values that fit in a 32-bit integer as discriminants. \
[INFO] [stdout] 2690 | |                              Expressions or variables are not supported.",
[INFO] [stdout] 2691 | |                         ),
[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:2706:21
[INFO] [stdout]      |
[INFO] [stdout] 2706 | /                     bail_span!(
[INFO] [stdout] 2707 | |                         v,
[INFO] [stdout] 2708 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2709 | |                         but `{1}` is too small for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2712 | |                         underlying
[INFO] [stdout] 2713 | |                     );
[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:2716:21
[INFO] [stdout]      |
[INFO] [stdout] 2716 | /                     bail_span!(
[INFO] [stdout] 2717 | |                         v,
[INFO] [stdout] 2718 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2719 | |                         but `{1}` is too large for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2722 | |                         underlying
[INFO] [stdout] 2723 | |                     );
[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:2728:21
[INFO] [stdout]      |
[INFO] [stdout] 2728 | /                     bail_span!(
[INFO] [stdout] 2729 | |                         v,
[INFO] [stdout] 2730 | |                         "discriminant value `{}` is already used by {} in this enum",
[INFO] [stdout] 2731 | |                         value,
[INFO] [stdout] 2732 | |                         old.ident
[INFO] [stdout] 2733 | |                     );
[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:2776:13
[INFO] [stdout]      |
[INFO] [stdout] 2776 | ...   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:3019:25
[INFO] [stdout]      |
[INFO] [stdout] 3019 | /                         bail_span!(
[INFO] [stdout] 3020 | |                             import_function.rust_name,
[INFO] [stdout] 3021 | |                             "Imported function cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3022 | |                             import_function.function.name
[INFO] [stdout] 3023 | |                         );
[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:3028:25
[INFO] [stdout]      |
[INFO] [stdout] 3028 | /                         bail_span!(
[INFO] [stdout] 3029 | |                             import_static.rust_name,
[INFO] [stdout] 3030 | |                             "Imported static cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3031 | |                             import_static.js_name
[INFO] [stdout] 3032 | |                         );
[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:3040:25
[INFO] [stdout]      |
[INFO] [stdout] 3040 | /                         bail_span!(
[INFO] [stdout] 3041 | |                             import_type.rust_name,
[INFO] [stdout] 3042 | |                             "Imported type cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3043 | |                             import_type.js_name
[INFO] [stdout] 3044 | |                         );
[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:3123:14
[INFO] [stdout]      |
[INFO] [stdout] 3123 |         _ => 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:3131:14
[INFO] [stdout]      |
[INFO] [stdout] 3131 |         _ => 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:3139:18
[INFO] [stdout]      |
[INFO] [stdout] 3139 |         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:3236:21
[INFO] [stdout]      |
[INFO] [stdout] 3236 | /                     bail_span!(
[INFO] [stdout] 3237 | |                         path,
[INFO] [stdout] 3238 | |                         "paths with type parameters are not supported in this position"
[INFO] [stdout] 3239 | |                     )
[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:3243:17
[INFO] [stdout]      |
[INFO] [stdout] 3243 |                 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:3251:13
[INFO] [stdout]      |
[INFO] [stdout] 3251 |             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:3257:5
[INFO] [stdout]      |
[INFO] [stdout] 3257 |     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:3390:9
[INFO] [stdout]      |
[INFO] [stdout] 3390 |         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:3393:9
[INFO] [stdout]      |
[INFO] [stdout] 3393 |         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:3396:9
[INFO] [stdout]      |
[INFO] [stdout] 3396 |         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:3399:9
[INFO] [stdout]      |
[INFO] [stdout] 3399 |         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] [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/lib.rs:82:13
[INFO] [stdout]    |
[INFO] [stdout] 82 | /             bail_span!(
[INFO] [stdout] 83 | |                 s.ident,
[INFO] [stdout] 84 | |                 "cannot resolve a path to the `wasm_bindgen` crate: add `wasm-bindgen` \
[INFO] [stdout] 85 | |                  as a direct dependency, or specify an explicit path with \
[INFO] [stdout] 86 | |                  `#[wasm_bindgen(wasm_bindgen = path::to::wasm_bindgen)]`"
[INFO] [stdout] 87 | |             );
[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` (lib) due to 94 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:736:13
[INFO] [stdout]     |
[INFO] [stdout] 736 | /             bail_span!(
[INFO] [stdout] 737 | |                 syn::token::Pub(self.name_span),
[INFO] [stdout] 738 | |                 "setters must start with `set_`, found: {}",
[INFO] [stdout] 739 | |                 name,
[INFO] [stdout] 740 | |             );
[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:1079:13
[INFO] [stdout]      |
[INFO] [stdout] 1079 |             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:2523:22
[INFO] [stdout]      |
[INFO] [stdout] 2523 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 2524 | |                     arg.pat_type.pat,
[INFO] [stdout] 2525 | |                     "unsupported pattern in #[wasm_bindgen] imported function",
[INFO] [stdout] 2526 | |                 ),
[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:2659:17
[INFO] [stdout]      |
[INFO] [stdout] 2659 | /                 bail_span!(
[INFO] [stdout] 2660 | |                     self.js_ret,
[INFO] [stdout] 2661 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 2662 | |                 );
[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:3140:13
[INFO] [stdout]      |
[INFO] [stdout] 3140 | /             bail_span!(
[INFO] [stdout] 3141 | |                 self.rust_name,
[INFO] [stdout] 3142 | |                 "experimental_generic_mono requires at least one type parameter"
[INFO] [stdout] 3143 | |             );
[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:3159:17
[INFO] [stdout]      |
[INFO] [stdout] 3159 | /                 bail_span!(
[INFO] [stdout] 3160 | |                     type_param,
[INFO] [stdout] 3161 | |                     "defaults for generic parameters are not allowed here"
[INFO] [stdout] 3162 | |                 );
[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:3256:25
[INFO] [stdout]      |
[INFO] [stdout] 3256 | / ...   bail_span!(
[INFO] [stdout] 3257 | | ...       class,
[INFO] [stdout] 3258 | | ...       "experimental_generic_mono requires static methods on imported classes with required generic parameters to write those...
[INFO] [stdout] 3259 | | ...   );
[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:3289:21
[INFO] [stdout]      |
[INFO] [stdout] 3289 | /                     bail_span!(
[INFO] [stdout] 3290 | |                         ty,
[INFO] [stdout] 3291 | |                         "experimental_generic_mono requires the `variadic` argument to be a sequence when \
[INFO] [stdout] 3292 | |                          it mentions a type parameter, because it is spread with `...` on the JS \
[INFO] [stdout] 3293 | |                          side and must be iterable for every monomorphisation; use `Vec<T>`, \
[INFO] [stdout] 3294 | |                          `[T; N]` or `&[T]`, or the type-erasure generic path instead"
[INFO] [stdout] 3295 | |                     );
[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:3313:21
[INFO] [stdout]      |
[INFO] [stdout] 3313 | /                     bail_span!(
[INFO] [stdout] 3314 | |                         err_ty,
[INFO] [stdout] 3315 | |                         "the error type of a `catch` import must be `JsValue`, not a type \
[INFO] [stdout] 3316 | |                          parameter; only the `Ok` type is monomorphised"
[INFO] [stdout] 3317 | |                     );
[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:3376:22
[INFO] [stdout]      |
[INFO] [stdout] 3376 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 3377 | |                     arg.pat_type.pat,
[INFO] [stdout] 3378 | |                     "unsupported pattern in experimental_generic_mono imported function",
[INFO] [stdout] 3379 | |                 ),
[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:3388:25
[INFO] [stdout]      |
[INFO] [stdout] 3388 | /                         bail_span!(
[INFO] [stdout] 3389 | |                             ty,
[INFO] [stdout] 3390 | |                             "experimental_generic_mono does not support higher-ranked generic callback signatures"
[INFO] [stdout] 3391 | |                         );
[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:3396:33
[INFO] [stdout]      |
[INFO] [stdout] 3396 | / ...                   bail_span!(
[INFO] [stdout] 3397 | | ...                       input,
[INFO] [stdout] 3398 | | ...                       "experimental_generic_mono does not support borrowed generic callback arguments"
[INFO] [stdout] 3399 | | ...                   );
[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:3408:29
[INFO] [stdout]      |
[INFO] [stdout] 3408 | / ...                   bail_span!(
[INFO] [stdout] 3409 | | ...                       ret,
[INFO] [stdout] 3410 | | ...                       "experimental_generic_mono does not support borrowed generic callback returns"
[INFO] [stdout] 3411 | | ...                   );
[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:3474:21
[INFO] [stdout]      |
[INFO] [stdout] 3474 | /                     bail_span!(
[INFO] [stdout] 3475 | |                         ty,
[INFO] [stdout] 3476 | |                         "experimental_generic_mono only supports a bare shared reference to a generic \
[INFO] [stdout] 3477 | |                          type parameter (`&T`); mutable references (`&mut T`) and references \
[INFO] [stdout] 3478 | |                          nested inside another type (e.g. `Option<&T>`) are not supported — \
[INFO] [stdout] 3479 | |                          take the argument by value or use the type-erasure generic path"
[INFO] [stdout] 3480 | |                     );
[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:3555:17
[INFO] [stdout]      |
[INFO] [stdout] 3555 | /                 bail_span!(
[INFO] [stdout] 3556 | |                     self.js_ret,
[INFO] [stdout] 3557 | |                     "cannot return references in #[wasm_bindgen] imports yet"
[INFO] [stdout] 3558 | |                 );
[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:4175:21
[INFO] [stdout]      |
[INFO] [stdout] 4175 | / ...   bail_span!(
[INFO] [stdout] 4176 | | ...       segment,
[INFO] [stdout] 4177 | | ...       "imported classes with lifetime parameters require explicit lifetime arguments on generated impls; name the lifetime a...
[INFO] [stdout] 4178 | | ...   );
[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:4188:25
[INFO] [stdout]      |
[INFO] [stdout] 4188 | /                         bail_span!(
[INFO] [stdout] 4189 | |                             class,
[INFO] [stdout] 4190 | |                             "wasm-bindgen cannot substitute a projected imported-type default for a non-path class argument"
[INFO] [stdout] 4191 | |                         );
[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:4210:17
[INFO] [stdout]      |
[INFO] [stdout] 4210 | /                 bail_span!(
[INFO] [stdout] 4211 | |                     class,
[INFO] [stdout] 4212 | |                     "an imported-class bound conflicts with a function lifetime of the same name"
[INFO] [stdout] 4213 | |                 );
[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:4216:17
[INFO] [stdout]      |
[INFO] [stdout] 4216 | /                 bail_span!(
[INFO] [stdout] 4217 | |                     class,
[INFO] [stdout] 4218 | |                     "wasm-bindgen cannot substitute an imported-type bound that projects a non-path class argument"
[INFO] [stdout] 4219 | |                 );
[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:4386:25
[INFO] [stdout]      |
[INFO] [stdout] 4386 |                         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/codegen.rs:4674:21
[INFO] [stdout]      |
[INFO] [stdout] 4674 | /                     bail_span!(
[INFO] [stdout] 4675 | |                         lt,
[INFO] [stdout] 4676 | |                         "wasm-bindgen does not support a lifetime argument on the class type \
[INFO] [stdout] 4677 | |                          that the function does not itself declare; name it as a lifetime \
[INFO] [stdout] 4678 | |                          parameter of the function (e.g. `fn f<'a, T>(this: &'a Holder<'a, T>)`)"
[INFO] [stdout] 4679 | |                     );
[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:4684:21
[INFO] [stdout]      |
[INFO] [stdout] 4684 | / ...   bail_span!(
[INFO] [stdout] 4685 | | ...       ty,
[INFO] [stdout] 4686 | | ...       "wasm-bindgen does not support elided lifetimes in class type arguments; name the lifetime as a function parameter"
[INFO] [stdout] 4687 | | ...   );
[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:4690:21
[INFO] [stdout]      |
[INFO] [stdout] 4690 | / ...   bail_span!(
[INFO] [stdout] 4691 | | ...       ty,
[INFO] [stdout] 4692 | | ...       "wasm-bindgen does not support inferred (`_`) class type arguments; use a concrete type or named function type parameter"
[INFO] [stdout] 4693 | | ...   );
[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:4698:21
[INFO] [stdout]      |
[INFO] [stdout] 4698 | / ...   bail_span!(
[INFO] [stdout] 4699 | | ...       ty,
[INFO] [stdout] 4700 | | ...       "wasm-bindgen does not support `impl Trait` in class type arguments; name it as a function type parameter (e.g. `fn f<...
[INFO] [stdout] 4701 | | ...   );
[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:4746:13
[INFO] [stdout]      |
[INFO] [stdout] 4746 | /             bail_span!(
[INFO] [stdout] 4747 | |                 self.rust_name,
[INFO] [stdout] 4748 | |                 "wasm-bindgen requires each generic argument of an impl class type to be either \
[INFO] [stdout] 4749 | |                  concrete or to determine a generic parameter of the function (e.g. \
[INFO] [stdout] ...    |
[INFO] [stdout] 4752 | |                  block cannot constrain it"
[INFO] [stdout] 4753 | |             );
[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:4887:13
[INFO] [stdout]      |
[INFO] [stdout] 4887 | / ...   bail_span!(
[INFO] [stdout] 4888 | | ...       ret_ty,
[INFO] [stdout] 4889 | | ...       "experimental_generic_mono cannot use a constructor or self-returning static method whose class return mixes a lifetim...
[INFO] [stdout] 4890 | | ...   );
[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:273:21
[INFO] [stdout]     |
[INFO] [stdout] 273 |                     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:580:13
[INFO] [stdout]     |
[INFO] [stdout] 580 | /             bail_span!(
[INFO] [stdout] 581 | |                 self.generics,
[INFO] [stdout] 582 | |                 "structs with #[wasm_bindgen] cannot have lifetime or \
[INFO] [stdout] 583 | |                  type parameters currently"
[INFO] [stdout] 584 | |             );
[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:657:13
[INFO] [stdout]     |
[INFO] [stdout] 657 | /             bail_span!(
[INFO] [stdout] 658 | |                 self.ident,
[INFO] [stdout] 659 | |                 "struct cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 660 | |                 js_name
[INFO] [stdout] 661 | |             );
[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:803:13
[INFO] [stdout]     |
[INFO] [stdout] 803 |             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:814:17
[INFO] [stdout]     |
[INFO] [stdout] 814 | /                 bail_span!(
[INFO] [stdout] 815 | |                     ident,
[INFO] [stdout] 816 | |                     "struct with `#[wasm_bindgen(extends = ...)]` cannot \
[INFO] [stdout] 817 | |                      have a field named `parent`; the macro injects one"
[INFO] [stdout] 818 | |                 );
[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:841:13
[INFO] [stdout]     |
[INFO] [stdout] 841 | /             bail_span!(
[INFO] [stdout] 842 | |                 &s.ident,
[INFO] [stdout] 843 | |                 "tuple structs cannot use `#[wasm_bindgen(extends = ...)]`; \
[INFO] [stdout] 844 | |                  use a named-field struct"
[INFO] [stdout] 845 | |             );
[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:998:22
[INFO] [stdout]      |
[INFO] [stdout]  998 |                   _ => bail_span!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout]  999 | |                     class.pat_type.ty,
[INFO] [stdout] 1000 | |                     "first argument of method must be a shared reference"
[INFO] [stdout] 1001 | |                 ),
[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:1016:22
[INFO] [stdout]      |
[INFO] [stdout] 1016 |                 _ => 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:1030:17
[INFO] [stdout]      |
[INFO] [stdout] 1030 | /                 bail_span!(
[INFO] [stdout] 1031 | |                     cls,
[INFO] [stdout] 1032 | |                     "static_method_of does not support qualified-self projections"
[INFO] [stdout] 1033 | |                 );
[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:1051:22
[INFO] [stdout]      |
[INFO] [stdout] 1051 |                 _ => 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:1059:22
[INFO] [stdout]      |
[INFO] [stdout] 1059 |                 _ => 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:1381:13
[INFO] [stdout]      |
[INFO] [stdout] 1381 |             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:1429:13
[INFO] [stdout]      |
[INFO] [stdout] 1429 |             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:1439:13
[INFO] [stdout]      |
[INFO] [stdout] 1439 | /             bail_span!(
[INFO] [stdout] 1440 | |                 self.expr,
[INFO] [stdout] 1441 | |                 "statics with a value can only be string literals"
[INFO] [stdout] 1442 | |             )
[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:1446:13
[INFO] [stdout]      |
[INFO] [stdout] 1446 | /             bail_span!(
[INFO] [stdout] 1447 | |                 self,
[INFO] [stdout] 1448 | |                 "static strings require `#[wasm_bindgen(static_string)]`"
[INFO] [stdout] 1449 | |             )
[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:1455:13
[INFO] [stdout]      |
[INFO] [stdout] 1455 | /             bail_span!(
[INFO] [stdout] 1456 | |                 self,
[INFO] [stdout] 1457 | |                 "static strings require `#[wasm_bindgen(thread_local_v2)]`"
[INFO] [stdout] 1458 | |             )
[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:1488:18
[INFO] [stdout]      |
[INFO] [stdout] 1488 |             _ => 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:1491:13
[INFO] [stdout]      |
[INFO] [stdout] 1491 | /             bail_span!(
[INFO] [stdout] 1492 | |                 self.sig.constness,
[INFO] [stdout] 1493 | |                 "can only #[wasm_bindgen] non-const functions"
[INFO] [stdout] 1494 | |             );
[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:1566:9
[INFO] [stdout]      |
[INFO] [stdout] 1566 |         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:1571:9
[INFO] [stdout]      |
[INFO] [stdout] 1571 | /         bail_span!(
[INFO] [stdout] 1572 | |             sig.generics,
[INFO] [stdout] 1573 | |             "can't #[wasm_bindgen] functions with lifetime or type parameters"
[INFO] [stdout] 1574 | |         );
[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:1634:25
[INFO] [stdout]      |
[INFO] [stdout] 1634 | / ...   bail_span!(
[INFO] [stdout] 1635 | | ...       r.self_token,
[INFO] [stdout] 1636 | | ...       "the `self` argument is only allowed for functions in `impl` blocks.\n\n\
[INFO] [stdout] 1637 | | ...       If the function is already in an `impl` block, did you perhaps forget to add `#[wasm_bindgen]` to the `impl` block?"
[INFO] [stdout] 1638 | | ...   );
[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:1641:25
[INFO] [stdout]      |
[INFO] [stdout] 1641 | /                         bail_span!(
[INFO] [stdout] 1642 | |                             r.self_token,
[INFO] [stdout] 1643 | |                             "the `self` argument is not allowed for `extern` functions.\n\n\
[INFO] [stdout] 1644 | |                             Did you perhaps mean `this`? For more information on importing JavaScript functions, see:\n\
[INFO] [stdout] 1645 | |                             https://wasm-bindgen.github.io/wasm-bindgen/examples/import-js.html"
[INFO] [stdout] 1646 | |                         );
[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:2022:25
[INFO] [stdout]      |
[INFO] [stdout] 2022 |                         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:2025:25
[INFO] [stdout]      |
[INFO] [stdout] 2025 |                         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:2044:21
[INFO] [stdout]      |
[INFO] [stdout] 2044 | /                     bail_span!(
[INFO] [stdout] 2045 | |                         &f.sig.inputs,
[INFO] [stdout] 2046 | |                         "functions taking a 'this' argument must have at least one parameter"
[INFO] [stdout] 2047 | |                     );
[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:2104:17
[INFO] [stdout]      |
[INFO] [stdout] 2104 | /                 bail_span!(
[INFO] [stdout] 2105 | |                     self,
[INFO] [stdout] 2106 | |                     "#[wasm_bindgen] can only be applied to a function, \
[INFO] [stdout] 2107 | |                      struct, enum, impl, or extern block",
[INFO] [stdout] 2108 | |                 );
[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:2119:13
[INFO] [stdout]      |
[INFO] [stdout] 2119 | /             bail_span!(
[INFO] [stdout] 2120 | |                 self.modifiers.defaultness,
[INFO] [stdout] 2121 | |                 "#[wasm_bindgen] default impls are not supported"
[INFO] [stdout] 2122 | |             );
[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:13
[INFO] [stdout]      |
[INFO] [stdout] 2125 | /             bail_span!(
[INFO] [stdout] 2126 | |                 self.unsafety,
[INFO] [stdout] 2127 | |                 "#[wasm_bindgen] unsafe impls are not supported"
[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:2131:13
[INFO] [stdout]      |
[INFO] [stdout] 2131 |             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:2134:13
[INFO] [stdout]      |
[INFO] [stdout] 2134 | /             bail_span!(
[INFO] [stdout] 2135 | |                 self.generics,
[INFO] [stdout] 2136 | |                 "#[wasm_bindgen] generic impls aren't supported"
[INFO] [stdout] 2137 | |             );
[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:2145:18
[INFO] [stdout]      |
[INFO] [stdout] 2145 |               _ => bail_span!(
[INFO] [stdout]      |  __________________-
[INFO] [stdout] 2146 | |                 self.self_ty,
[INFO] [stdout] 2147 | |                 "unsupported self type in #[wasm_bindgen] impl"
[INFO] [stdout] 2148 | |             ),
[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:2179:13
[INFO] [stdout]      |
[INFO] [stdout] 2179 | /             bail_span!(
[INFO] [stdout] 2180 | |                 &*item,
[INFO] [stdout] 2181 | |                 "const definitions aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 2182 | |             );
[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:2184:35
[INFO] [stdout]      |
[INFO] [stdout] 2184 |           syn::ImplItem::Type(_) => bail_span!(
[INFO] [stdout]      |  ___________________________________-
[INFO] [stdout] 2185 | |             &*item,
[INFO] [stdout] 2186 | |             "type definitions in impls aren't supported with #[wasm_bindgen]"
[INFO] [stdout] 2187 | |         ),
[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:2193:13
[INFO] [stdout]      |
[INFO] [stdout] 2193 |             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:2196:18
[INFO] [stdout]      |
[INFO] [stdout] 2196 |         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:2289:13
[INFO] [stdout]      |
[INFO] [stdout] 2289 | /             bail_span!(
[INFO] [stdout] 2290 | |                 self.sig.constness,
[INFO] [stdout] 2291 | |                 "can only #[wasm_bindgen] non-const functions",
[INFO] [stdout] 2292 | |             );
[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:2298:13
[INFO] [stdout]      |
[INFO] [stdout] 2298 | /             bail_span!(
[INFO] [stdout] 2299 | |                 &self.sig.ident,
[INFO] [stdout] 2300 | |                 "#[wasm_bindgen(this)] cannot be used on impl block methods; \
[INFO] [stdout] 2301 | |                  it is only valid on free functions"
[INFO] [stdout] 2302 | |             );
[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:2404:17
[INFO] [stdout]      |
[INFO] [stdout] 2404 |                 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:2415:21
[INFO] [stdout]      |
[INFO] [stdout] 2415 |               expr => bail_span!(
[INFO] [stdout]      |  _____________________-
[INFO] [stdout] 2416 | |                 expr,
[INFO] [stdout] 2417 | |                 "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2418 | |             ),
[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:2465:25
[INFO] [stdout]      |
[INFO] [stdout] 2465 | /                         bail_span!(
[INFO] [stdout] 2466 | |                             v,
[INFO] [stdout] 2467 | |                             "all unit variants of a string enum must have a string value"
[INFO] [stdout] 2468 | |                         );
[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:2480:29
[INFO] [stdout]      |
[INFO] [stdout] 2480 |                       expr => bail_span!(
[INFO] [stdout]      |  _____________________________-
[INFO] [stdout] 2481 | |                         expr,
[INFO] [stdout] 2482 | |                         "enums with #[wasm_bindgen] cannot mix string and non-string values",
[INFO] [stdout] 2483 | |                     ),
[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:2494:17
[INFO] [stdout]      |
[INFO] [stdout] 2494 | /                 bail_span!(
[INFO] [stdout] 2495 | |                     v.fields,
[INFO] [stdout] 2496 | |                     "string enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2497 | |                 );
[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:2572:13
[INFO] [stdout]      |
[INFO] [stdout] 2572 |             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:2583:13
[INFO] [stdout]      |
[INFO] [stdout] 2583 | /             bail_span!(
[INFO] [stdout] 2584 | |                 self.ident,
[INFO] [stdout] 2585 | |                 "enum cannot use the JS keyword `{}` as its name",
[INFO] [stdout] 2586 | |                 js_name
[INFO] [stdout] 2587 | |             );
[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:2601:44
[INFO] [stdout]      |
[INFO] [stdout] 2601 |                   syn::Fields::Unnamed(_) => bail_span!(
[INFO] [stdout]      |  ____________________________________________-
[INFO] [stdout] 2602 | |                     variant.fields,
[INFO] [stdout] 2603 | |                     "enum variants with fields must have exactly one unnamed field"
[INFO] [stdout] 2604 | |                 ),
[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:2606:21
[INFO] [stdout]      |
[INFO] [stdout] 2606 |                     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:2624:13
[INFO] [stdout]      |
[INFO] [stdout] 2624 | /             bail_span!(
[INFO] [stdout] 2625 | |                 self,
[INFO] [stdout] 2626 | |                 "the `fallback` attribute is only supported on dynamic unions \
[INFO] [stdout] 2627 | |                  (enums with at least one tuple variant)"
[INFO] [stdout] 2628 | |             );
[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:2658:18
[INFO] [stdout]      |
[INFO] [stdout] 2658 |             _ => 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:2686:30
[INFO] [stdout]      |
[INFO] [stdout] 2686 |                           _ => bail_span!(
[INFO] [stdout]      |  ______________________________-
[INFO] [stdout] 2687 | |                             expr,
[INFO] [stdout] 2688 | |                             "C-style enums with #[wasm_bindgen] may only have \
[INFO] [stdout] 2689 | |                              numeric literal values that fit in a 32-bit integer as discriminants. \
[INFO] [stdout] 2690 | |                              Expressions or variables are not supported.",
[INFO] [stdout] 2691 | |                         ),
[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:2706:21
[INFO] [stdout]      |
[INFO] [stdout] 2706 | /                     bail_span!(
[INFO] [stdout] 2707 | |                         v,
[INFO] [stdout] 2708 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2709 | |                         but `{1}` is too small for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2712 | |                         underlying
[INFO] [stdout] 2713 | |                     );
[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:2716:21
[INFO] [stdout]      |
[INFO] [stdout] 2716 | /                     bail_span!(
[INFO] [stdout] 2717 | |                         v,
[INFO] [stdout] 2718 | |                         "C-style enums with #[wasm_bindgen] can only support {0} that can be represented by `{2}`, \
[INFO] [stdout] 2719 | |                         but `{1}` is too large for `{2}`",
[INFO] [stdout] ...    |
[INFO] [stdout] 2722 | |                         underlying
[INFO] [stdout] 2723 | |                     );
[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:2728:21
[INFO] [stdout]      |
[INFO] [stdout] 2728 | /                     bail_span!(
[INFO] [stdout] 2729 | |                         v,
[INFO] [stdout] 2730 | |                         "discriminant value `{}` is already used by {} in this enum",
[INFO] [stdout] 2731 | |                         value,
[INFO] [stdout] 2732 | |                         old.ident
[INFO] [stdout] 2733 | |                     );
[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:2776:13
[INFO] [stdout]      |
[INFO] [stdout] 2776 | ...   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:3019:25
[INFO] [stdout]      |
[INFO] [stdout] 3019 | /                         bail_span!(
[INFO] [stdout] 3020 | |                             import_function.rust_name,
[INFO] [stdout] 3021 | |                             "Imported function cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3022 | |                             import_function.function.name
[INFO] [stdout] 3023 | |                         );
[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:3028:25
[INFO] [stdout]      |
[INFO] [stdout] 3028 | /                         bail_span!(
[INFO] [stdout] 3029 | |                             import_static.rust_name,
[INFO] [stdout] 3030 | |                             "Imported static cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3031 | |                             import_static.js_name
[INFO] [stdout] 3032 | |                         );
[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:3040:25
[INFO] [stdout]      |
[INFO] [stdout] 3040 | /                         bail_span!(
[INFO] [stdout] 3041 | |                             import_type.rust_name,
[INFO] [stdout] 3042 | |                             "Imported type cannot use the JS keyword `{}` as its name.",
[INFO] [stdout] 3043 | |                             import_type.js_name
[INFO] [stdout] 3044 | |                         );
[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:3123:14
[INFO] [stdout]      |
[INFO] [stdout] 3123 |         _ => 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:3131:14
[INFO] [stdout]      |
[INFO] [stdout] 3131 |         _ => 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:3139:18
[INFO] [stdout]      |
[INFO] [stdout] 3139 |         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:3236:21
[INFO] [stdout]      |
[INFO] [stdout] 3236 | /                     bail_span!(
[INFO] [stdout] 3237 | |                         path,
[INFO] [stdout] 3238 | |                         "paths with type parameters are not supported in this position"
[INFO] [stdout] 3239 | |                     )
[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:3243:17
[INFO] [stdout]      |
[INFO] [stdout] 3243 |                 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:3251:13
[INFO] [stdout]      |
[INFO] [stdout] 3251 |             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:3257:5
[INFO] [stdout]      |
[INFO] [stdout] 3257 |     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:3390:9
[INFO] [stdout]      |
[INFO] [stdout] 3390 |         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:3393:9
[INFO] [stdout]      |
[INFO] [stdout] 3393 |         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:3396:9
[INFO] [stdout]      |
[INFO] [stdout] 3396 |         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:3399:9
[INFO] [stdout]      |
[INFO] [stdout] 3399 |         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] [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/lib.rs:82:13
[INFO] [stdout]    |
[INFO] [stdout] 82 | /             bail_span!(
[INFO] [stdout] 83 | |                 s.ident,
[INFO] [stdout] 84 | |                 "cannot resolve a path to the `wasm_bindgen` crate: add `wasm-bindgen` \
[INFO] [stdout] 85 | |                  as a direct dependency, or specify an explicit path with \
[INFO] [stdout] 86 | |                  `#[wasm_bindgen(wasm_bindgen = path::to::wasm_bindgen)]`"
[INFO] [stdout] 87 | |             );
[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` (lib test) due to 94 previous errors
[INFO] running `Command { std: "docker" "inspect" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487", kill_on_drop: false }`
[INFO] [stdout] f9d0fed4ad657ba81a794f7267fb776095893573990d144346a56968a2809487
