[INFO] cloning repository https://github.com/computatorium/mangler
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/computatorium/mangler" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fcomputatorium%2Fmangler", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fcomputatorium%2Fmangler'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 1ad5b5f85f9c42912e92511e8b6a069343f7f885
[INFO] checking computatorium/mangler against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fcomputatorium%2Fmangler" "/workspace/builds/worker-5-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-5-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/computatorium/mangler
[INFO] finished tweaking git repo https://github.com/computatorium/mangler
[INFO] tweaked toml for git repo https://github.com/computatorium/mangler written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/computatorium/mangler on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/computatorium/mangler 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] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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] 664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2
[INFO] running `Command { std: "docker" "start" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2", 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" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2", 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" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking allocator-api2 v0.2.21
[INFO] [stderr]     Checking smallvec v1.15.2
[INFO] [stderr]    Compiling libc v0.2.186
[INFO] [stderr]    Compiling ahash v0.8.12
[INFO] [stderr]    Compiling zerocopy v0.8.52
[INFO] [stderr]    Compiling phf_shared v0.11.3
[INFO] [stderr]    Compiling zerovec-derive v0.11.3
[INFO] [stderr]    Compiling displaydoc v0.2.6
[INFO] [stderr]    Compiling swc_macros_common v1.0.1
[INFO] [stderr]     Checking serde v1.0.228
[INFO] [stderr]    Compiling zerofrom-derive v0.1.7
[INFO] [stderr]    Compiling yoke-derive v0.8.2
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]     Checking better_scoped_tls v1.0.1
[INFO] [stderr]     Checking swc_visit v2.0.1
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]    Compiling swc_eq_ignore_macros v1.0.1
[INFO] [stderr]    Compiling is-macro v0.3.7
[INFO] [stderr]     Checking unicode-id-start v1.4.0
[INFO] [stderr]     Checking swc_ecma_regexp_common v0.0.1
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]    Compiling dragonbox_ecma v0.1.12
[INFO] [stderr]     Checking castaway v0.2.4
[INFO] [stderr]     Checking par-core v2.0.0
[INFO] [stderr]     Checking compact_str v0.7.1
[INFO] [stderr]    Compiling seq-macro v0.3.6
[INFO] [stderr]     Checking serde_json v1.0.150
[INFO] [stderr]     Checking hashbrown v0.14.5
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]    Compiling thiserror-impl v2.0.18
[INFO] [stderr]     Checking rand v0.10.1
[INFO] [stderr]     Checking triomphe v0.1.15
[INFO] [stderr]    Compiling getrandom v0.2.17
[INFO] [stderr]     Checking bytes-str v0.2.8
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling from_variant v3.0.0
[INFO] [stderr]    Compiling ast_node v7.0.0
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]    Compiling string_enum v1.0.2
[INFO] [stderr]     Checking aho-corasick v1.1.4
[INFO] [stderr]     Checking data-encoding v2.11.0
[INFO] [stderr]     Checking rand_chacha v0.10.0
[INFO] [stderr]     Checking hstr v4.0.1
[INFO] [stderr]     Checking uuid v1.23.3
[INFO] [stderr]     Checking vsimd v0.8.0
[INFO] [stderr]     Checking indexmap v2.14.0
[INFO] [stderr]     Checking outref v0.5.2
[INFO] [stderr]     Checking dashmap v6.2.1
[INFO] [stderr]     Checking zerofrom v0.1.8
[INFO] [stderr]     Checking swc_atoms v10.0.0
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking yoke v0.8.3
[INFO] [stderr]     Checking bstr v1.12.1
[INFO] [stderr]     Checking if_chain v1.0.3
[INFO] [stderr]    Compiling swc_ecma_transforms_macros v1.0.1
[INFO] [stderr]    Compiling swc_config_macro v1.0.1
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]     Checking zerovec v0.11.6
[INFO] [stderr]     Checking zerotrie v0.2.4
[INFO] [stderr]     Checking debugid v0.8.0
[INFO] [stderr]     Checking fixedbitset v0.5.7
[INFO] [stderr]     Checking swc_allocator v5.0.0
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]    Compiling swc_ecma_codegen_macros v2.0.2
[INFO] [stderr]     Checking ascii v1.1.0
[INFO] [stderr]     Checking par-iter v2.0.0
[INFO] [stderr]     Checking base64-simd v0.8.0
[INFO] [stderr]     Checking petgraph v0.7.1
[INFO] [stderr]     Checking ryu-js v1.0.2
[INFO] [stderr]    Compiling swc_core v78.0.0
[INFO] [stderr]     Checking regex-automata v0.4.14
[INFO] [stderr]     Checking radix_fmt v1.0.0
[INFO] [stderr]    Compiling mangler-vm v0.2.0 (/opt/rustwide/workdir/crates/mangler-vm)
[INFO] [stderr]     Checking rustix v1.1.4
[INFO] [stderr]    Compiling cc v1.2.64
[INFO] [stderr]     Checking wait-timeout v0.2.1
[INFO] [stderr]     Checking relative-path v2.0.1
[INFO] [stderr]     Checking rand v0.9.4
[INFO] [stderr]     Checking thiserror v2.0.18
[INFO] [stderr]     Checking rand_xorshift v0.4.0
[INFO] [stderr]     Checking mangler-core v0.2.0 (/opt/rustwide/workdir/crates/mangler-core)
[INFO] [stderr]     Checking regress v0.11.1
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]     Checking mangler-passgraph v0.2.0 (/opt/rustwide/workdir/crates/mangler-passgraph)
[INFO] [stderr]    Compiling clap_derive v4.6.1
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]    Compiling getrandom v0.1.16
[INFO] [stderr]    Compiling cssparser-macros v0.6.1
[INFO] [stderr]     Checking phf_shared v0.8.0
[INFO] [stderr]    Compiling phf_shared v0.10.0
[INFO] [stderr]     Checking ahash v0.7.8
[INFO] [stderr]    Compiling rand_core v0.5.1
[INFO] [stderr]    Compiling rkyv v0.7.46
[INFO] [stderr]     Checking outref v0.1.0
[INFO] [stderr]     Checking hashbrown v0.12.3
[INFO] [stderr]     Checking simd-abstraction v0.7.1
[INFO] [stderr]     Checking string_cache v0.8.9
[INFO] [stderr]     Checking nodrop v0.1.14
[INFO] [stderr]    Compiling rand_pcg v0.2.1
[INFO] [stderr]     Checking seahash v4.1.0
[INFO] [stderr]    Compiling derive_more v0.99.20
[INFO] [stderr]     Checking fxhash v0.2.1
[INFO] [stderr]    Compiling convert_case v0.6.0
[INFO] [stderr]     Checking servo_arc v0.2.0
[INFO] [stderr]     Checking base64-simd v0.7.0
[INFO] [stderr]     Checking data-url v0.1.1
[INFO] [stderr]     Checking vlq v0.5.1
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking dashmap v5.5.3
[INFO] [stderr]     Checking toml_datetime v0.6.11
[INFO] [stderr]     Checking serde-content v0.1.2
[INFO] [stderr]     Checking tinystr v0.8.3
[INFO] [stderr]     Checking icu_locale_core v2.2.0
[INFO] [stderr]     Checking potential_utf v0.1.5
[INFO] [stderr]     Checking serde_spanned v0.6.9
[INFO] [stderr]     Checking icu_collections v2.2.0
[INFO] [stderr]     Checking itertools v0.10.5
[INFO] [stderr]    Compiling pastey v0.1.1
[INFO] [stderr]     Checking toml_edit v0.22.27
[INFO] [stderr]    Compiling rquickjs-sys v0.12.0
[INFO] [stderr]     Checking tempfile v3.27.0
[INFO] [stderr]     Checking rusty-fork v0.3.1
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]     Checking proptest v1.11.0
[INFO] [stderr]     Checking mangler-config v0.2.0 (/opt/rustwide/workdir/crates/mangler-config)
[INFO] [stderr]     Checking icu_provider v2.2.0
[INFO] [stderr]     Checking regex v1.12.4
[INFO] [stderr]     Checking globset v0.4.18
[INFO] [stderr]     Checking icu_normalizer v2.2.0
[INFO] [stderr]     Checking icu_properties v2.2.0
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand_chacha v0.2.2
[INFO] [stderr]    Compiling rand v0.7.3
[INFO] [stderr]    Compiling rand v0.8.6
[INFO] [stderr]     Checking toml v0.8.23
[INFO] [stderr]    Compiling phf_generator v0.8.0
[INFO] [stderr]    Compiling phf_codegen v0.8.0
[INFO] [stderr]    Compiling phf_generator v0.11.3
[INFO] [stderr]    Compiling phf_generator v0.10.0
[INFO] [stderr]     Checking idna_adapter v1.2.2
[INFO] [stderr]    Compiling phf_codegen v0.11.3
[INFO] [stderr]    Compiling string_cache_codegen v0.5.4
[INFO] [stderr]    Compiling selectors v0.24.0
[INFO] [stderr]    Compiling phf_macros v0.11.3
[INFO] [stderr]     Checking idna v1.1.0
[INFO] [stderr]    Compiling parcel_selectors v0.28.2
[INFO] [stderr]     Checking url v2.5.8
[INFO] [stderr]    Compiling markup5ever v0.14.1
[INFO] [stderr]     Checking phf v0.11.3
[INFO] [stderr]     Checking swc_common v26.0.0
[INFO] [stderr]     Checking swc_sourcemap v10.0.2
[INFO] [stderr]     Checking html5ever v0.29.1
[INFO] [stderr]    Compiling phf_macros v0.8.0
[INFO] [stderr]    Compiling cssparser v0.29.6
[INFO] [stderr]    Compiling phf_macros v0.10.0
[INFO] [stderr]    Compiling ptr_meta_derive v0.1.4
[INFO] [stderr]    Compiling rkyv_derive v0.7.46
[INFO] [stderr]    Compiling const-str-proc-macro v0.3.2
[INFO] [stderr]    Compiling lightningcss-derive v1.0.0-alpha.43
[INFO] [stderr]     Checking swc_config v6.0.0
[INFO] [stderr]     Checking ptr_meta v0.1.4
[INFO] [stderr]     Checking phf v0.8.0
[INFO] [stderr]     Checking const-str v0.3.2
[INFO] [stderr]     Checking cssparser v0.33.0
[INFO] [stderr]     Checking phf v0.10.1
[INFO] [stderr]     Checking swc_ecma_ast v29.0.0
[INFO] [stderr]     Checking swc_ecma_regexp_ast v3.0.0
[INFO] [stderr]     Checking cssparser-color v0.1.0
[INFO] [stderr]     Checking swc_ecma_regexp_visit v0.15.0
[INFO] [stderr]     Checking swc_ecma_regexp v0.15.0 (/opt/rustwide/workdir/vendor/swc_ecma_regexp-0.15.0)
[INFO] [stderr]     Checking swc_ecma_compat_regexp v9.0.0
[INFO] [stderr]     Checking kuchikiki v0.8.8-speedreader
[INFO] [stderr]     Checking mangler-html v0.2.0 (/opt/rustwide/workdir/crates/mangler-html)
[INFO] [stderr]     Checking rquickjs-core v0.12.0
[INFO] [stderr]     Checking parcel_sourcemap v2.1.1
[INFO] [stderr]     Checking lightningcss v1.0.0-alpha.71
[INFO] [stderr]     Checking swc_ecma_visit v29.0.0
[INFO] [stderr]     Checking swc_ecma_parser v45.1.1 (/opt/rustwide/workdir/vendor/swc_ecma_parser-45.1.1)
[INFO] [stderr]     Checking rquickjs v0.12.0
[INFO] [stderr]     Checking mangler-testkit v0.2.0 (/opt/rustwide/workdir/crates/mangler-testkit)
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:78:9
[INFO] [stdout]    |
[INFO] [stdout] 78 |           expect!(p, Token::Comma);
[INFO] [stdout]    |           ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::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: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:160:17
[INFO] [stdout]     |
[INFO] [stdout] 160 |                 syntax_error!(self, self.input().cur_span(), SyntaxError::ExportNotAllowed);
[INFO] [stdout]     |                 --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:167:17
[INFO] [stdout]     |
[INFO] [stdout] 167 |                 syntax_error!(self, self.span(start), SyntaxError::DecoratorOnExport);
[INFO] [stdout]     |                 --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:174:13
[INFO] [stdout]     |
[INFO] [stdout] 174 |             syntax_error!(self, self.span(start), SyntaxError::InvalidLeadingDecorator)
[INFO] [stdout]     |             --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:188:13
[INFO] [stdout]     |
[INFO] [stdout] 188 |               expect!(self, Token::RParen);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:319:13
[INFO] [stdout]     |
[INFO] [stdout] 319 |               unexpected!(self, "checks");
[INFO] [stdout]     |               --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:327:13
[INFO] [stdout]     |
[INFO] [stdout] 327 |               expect!(self, Token::RParen);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:364:13
[INFO] [stdout]     |
[INFO] [stdout] 364 |               expect!(p, Token::LParen);
[INFO] [stdout]     |               ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:402:13
[INFO] [stdout]     |
[INFO] [stdout] 402 |               expect!(p, Token::RParen);
[INFO] [stdout]     |               ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:484:9
[INFO] [stdout]     |
[INFO] [stdout] 484 |           expect!(self, Token::Async);
[INFO] [stdout]     |           --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:495:9
[INFO] [stdout]     |
[INFO] [stdout] 495 |           expect!(self, Token::Async);
[INFO] [stdout]     |           --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:509:9
[INFO] [stdout]     |
[INFO] [stdout] 509 |           expect!(self, Token::Async);
[INFO] [stdout]     |           --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:582:21
[INFO] [stdout]     |
[INFO] [stdout] 582 |                       unexpected!(p, "{");
[INFO] [stdout]     |                       ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:627:26
[INFO] [stdout]     |
[INFO] [stdout] 627 |             Err(kind) => syntax_error!(self, kind),
[INFO] [stdout]     |                          ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:965:13
[INFO] [stdout]     |
[INFO] [stdout] 965 |             syntax_error!(self, key.span(), SyntaxError::PropertyNamedConstructor);
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1337:17
[INFO] [stdout]      |
[INFO] [stdout] 1337 |                 syntax_error!(self, self.span(start), SyntaxError::ReadOnlyMethod);
[INFO] [stdout]      |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1383:25
[INFO] [stdout]      |
[INFO] [stdout] 1383 |                           expect!(self, Token::LParen);
[INFO] [stdout]      |                           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1393:25
[INFO] [stdout]      |
[INFO] [stdout] 1393 |                           expect!(self, Token::RParen);
[INFO] [stdout]      |                           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1558:17
[INFO] [stdout]      |
[INFO] [stdout] 1558 |                 syntax_error!(self, key.span(), SyntaxError::AsyncConstructor)
[INFO] [stdout]      |                 -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1561:17
[INFO] [stdout]      |
[INFO] [stdout] 1561 |                 syntax_error!(self, self.span(start), SyntaxError::ReadOnlyMethod);
[INFO] [stdout]      |                 ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:1677:9
[INFO] [stdout]      |
[INFO] [stdout] 1677 |           unexpected!(self, "* for generator, private key, identifier or async")
[INFO] [stdout]      |           ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:2017:26
[INFO] [stdout]      |
[INFO] [stdout] 2017 |             Err(kind) => syntax_error!(self, kind),
[INFO] [stdout]      |                          ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:2030:13
[INFO] [stdout]      |
[INFO] [stdout] 2030 |               expect!(p, Token::Class);
[INFO] [stdout]      |               ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:2123:13
[INFO] [stdout]      |
[INFO] [stdout] 2123 |               expect!(p, Token::LBrace);
[INFO] [stdout]      |               ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/class_and_fn.rs:2138:17
[INFO] [stdout]      |
[INFO] [stdout] 2138 |                   expect!(p, Token::RBrace);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:203:30
[INFO] [stdout]     |
[INFO] [stdout] 203 |                           _ => unexpected!(p, "("),
[INFO] [stdout]     |                                ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:544:17
[INFO] [stdout]     |
[INFO] [stdout] 544 |                   expect!(self, Token::LParen);
[INFO] [stdout]     |                   ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:599:13
[INFO] [stdout]     |
[INFO] [stdout] 599 |               expect!(self, Token::LParen);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:619:13
[INFO] [stdout]     |
[INFO] [stdout] 619 |               expect!(self, Token::RBracket);
[INFO] [stdout]     |               ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:631:17
[INFO] [stdout]     |
[INFO] [stdout] 631 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:639:17
[INFO] [stdout]     |
[INFO] [stdout] 639 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:647:9
[INFO] [stdout]     |
[INFO] [stdout] 647 |           expect!(self, Token::RBracket);
[INFO] [stdout]     |           ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:668:13
[INFO] [stdout]     |
[INFO] [stdout] 668 |             syntax_error!(self, self.input().prev_span(), SyntaxError::YieldParamInGen)
[INFO] [stdout]     |             --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:893:17
[INFO] [stdout]     |
[INFO] [stdout] 893 |                   unexpected!(self, "`}`")
[INFO] [stdout]     |                   ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1063:13
[INFO] [stdout]      |
[INFO] [stdout] 1063 |               expect!(p, Token::LParen);
[INFO] [stdout]      |               ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1066:17
[INFO] [stdout]      |
[INFO] [stdout] 1066 |                   expect!(p, Token::RParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1077:21
[INFO] [stdout]      |
[INFO] [stdout] 1077 |                       expect!(p, Token::Comma);
[INFO] [stdout]      |                       ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1081:29
[INFO] [stdout]      |
[INFO] [stdout] 1081 | ...                   syntax_error!(p, p.span(start), SyntaxError::TrailingCommaInsideImport)
[INFO] [stdout]      |                       ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1091:13
[INFO] [stdout]      |
[INFO] [stdout] 1091 |               expect!(p, Token::RParen);
[INFO] [stdout]      |               ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1119:25
[INFO] [stdout]      |
[INFO] [stdout] 1119 |                         syntax_error!(self, expr.span(), SyntaxError::InvalidAssignTarget)
[INFO] [stdout]      |                         ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1145:25
[INFO] [stdout]      |
[INFO] [stdout] 1145 |                         syntax_error!(self, v.span(), SyntaxError::InvalidAssignTarget);
[INFO] [stdout]      |                         --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1185:13
[INFO] [stdout]      |
[INFO] [stdout] 1185 |               expect!(self, Token::Colon);
[INFO] [stdout]      |               --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1386:29
[INFO] [stdout]      |
[INFO] [stdout] 1386 |   ...                   unexpected!(p, "`")
[INFO] [stdout]      |                         ------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1388:29
[INFO] [stdout]      |
[INFO] [stdout] 1388 |   ...                   unexpected!(p, "( or `")
[INFO] [stdout]      |                         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1419:13
[INFO] [stdout]      |
[INFO] [stdout] 1419 |               expect!(self, Token::RBracket);
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1639:13
[INFO] [stdout]      |
[INFO] [stdout] 1639 |               expect!(self, Token::RBracket);
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1754:17
[INFO] [stdout]      |
[INFO] [stdout] 1754 |                   expect!(self, Token::RBracket);
[INFO] [stdout]      |                   ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1765:21
[INFO] [stdout]      |
[INFO] [stdout] 1765 |                     syntax_error!(self, lhs.span, SyntaxError::InvalidSuper)
[INFO] [stdout]      |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1780:21
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                     syntax_error!(self, lhs.span, SyntaxError::InvalidSuperCall)
[INFO] [stdout]      |                     ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1804:21
[INFO] [stdout]      |
[INFO] [stdout] 1804 |                     syntax_error!(self, lhs.span, SyntaxError::InvalidSuper);
[INFO] [stdout]      |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1813:29
[INFO] [stdout]      |
[INFO] [stdout] 1813 | / ...                   syntax_error!(
[INFO] [stdout] 1814 | | ...                       self,
[INFO] [stdout] 1815 | | ...                       self.input().cur_span(),
[INFO] [stdout] 1816 | | ...                       SyntaxError::InvalidSuperCall
[INFO] [stdout] 1817 | | ...                   )
[INFO] [stdout]      | |_______________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1829:21
[INFO] [stdout]      |
[INFO] [stdout] 1829 |                     syntax_error!(self, self.input().cur_span(), SyntaxError::InvalidSuperCall)
[INFO] [stdout]      |                     --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1831:21
[INFO] [stdout]      |
[INFO] [stdout] 1831 |                     syntax_error!(self, self.input().cur_span(), SyntaxError::InvalidSuper)
[INFO] [stdout]      |                     ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1850:17
[INFO] [stdout]      |
[INFO] [stdout] 1850 | /                 syntax_error!(
[INFO] [stdout] 1851 | |                     self,
[INFO] [stdout] 1852 | |                     self.span(start),
[INFO] [stdout] 1853 | |                     SyntaxError::ImportRequiresOneOrTwoArgs
[INFO] [stdout] 1854 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1870:9
[INFO] [stdout]      |
[INFO] [stdout] 1870 |         syntax_error!(self, self.input().cur_span(), SyntaxError::InvalidImport);
[INFO] [stdout]      |         ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1897:22
[INFO] [stdout]      |
[INFO] [stdout] 1897 |                   _ => unexpected!(self, "meta"),
[INFO] [stdout]      |                        ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1958:17
[INFO] [stdout]      |
[INFO] [stdout] 1958 |                   unexpected!(self, "target")
[INFO] [stdout]      |                   --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1972:25
[INFO] [stdout]      |
[INFO] [stdout] 1972 |                         syntax_error!(self, span, SyntaxError::OptChainCannotFollowConstructorCall)
[INFO] [stdout]      |                         --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:1981:29
[INFO] [stdout]      |
[INFO] [stdout] 1981 | / ...                   syntax_error!(
[INFO] [stdout] 1982 | | ...                       self,
[INFO] [stdout] 1983 | | ...                       span,
[INFO] [stdout] 1984 | | ...                       SyntaxError::OptChainCannotFollowConstructorCall
[INFO] [stdout] 1985 | | ...                   )
[INFO] [stdout]      | |_______________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2005:25
[INFO] [stdout]      |
[INFO] [stdout] 2005 |                         syntax_error!(p, span, SyntaxError::Expected('('.to_string(), cur))
[INFO] [stdout]      |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2259:21
[INFO] [stdout]      |
[INFO] [stdout] 2259 | /                     syntax_error!(
[INFO] [stdout] 2260 | |                         self,
[INFO] [stdout] 2261 | |                         SyntaxError::UnaryInExp {
[INFO] [stdout] ...    |
[INFO] [stdout] 2266 | |                     )
[INFO] [stdout]      | |_____________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2346:13
[INFO] [stdout]      |
[INFO] [stdout] 2346 |             syntax_error!(self, SyntaxError::AwaitStar);
[INFO] [stdout]      |             ------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2453:9
[INFO] [stdout]      |
[INFO] [stdout] 2453 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2519:33
[INFO] [stdout]      |
[INFO] [stdout] 2519 | / ...                   syntax_error!(
[INFO] [stdout] 2520 | | ...                       self,
[INFO] [stdout] 2521 | | ...                       arg.span(),
[INFO] [stdout] 2522 | | ...                       SyntaxError::TsBindingPatCannotBeOptional
[INFO] [stdout] 2523 | | ...                   )
[INFO] [stdout]      | |_______________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2528:25
[INFO] [stdout]      |
[INFO] [stdout] 2528 |                           expect!(self, Token::QuestionMark);
[INFO] [stdout]      |                           ---------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2537:25
[INFO] [stdout]      |
[INFO] [stdout] 2537 |                           expect!(self, Token::Colon);
[INFO] [stdout]      |                           --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2735:17
[INFO] [stdout]      |
[INFO] [stdout] 2735 |                   expect!(self, Token::Comma);
[INFO] [stdout]      |                   --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2742:9
[INFO] [stdout]      |
[INFO] [stdout] 2742 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2802:17
[INFO] [stdout]      |
[INFO] [stdout] 2802 |                   expect!(p, Token::Arrow);
[INFO] [stdout]      |                   ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2812:21
[INFO] [stdout]      |
[INFO] [stdout] 2812 |                       unexpected!(p, "fail")
[INFO] [stdout]      |                       ---------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2850:21
[INFO] [stdout]      |
[INFO] [stdout] 2850 |                       unexpected!(p, "fail")
[INFO] [stdout]      |                       ---------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2890:17
[INFO] [stdout]      |
[INFO] [stdout] 2890 | /                 syntax_error!(
[INFO] [stdout] 2891 | |                     self,
[INFO] [stdout] 2892 | |                     self.span(expr_start),
[INFO] [stdout] 2893 | |                     SyntaxError::LineBreakBeforeArrow
[INFO] [stdout] 2894 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2898:17
[INFO] [stdout]      |
[INFO] [stdout] 2898 |                 syntax_error!(self, self.span(expr_start), SyntaxError::ArrowNotAllowed);
[INFO] [stdout]      |                 ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2900:13
[INFO] [stdout]      |
[INFO] [stdout] 2900 |               expect!(self, Token::Arrow);
[INFO] [stdout]      |               --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:2984:26
[INFO] [stdout]      |
[INFO] [stdout] 2984 |                     _ => syntax_error!(self, item.span(), SyntaxError::InvalidExpr),
[INFO] [stdout]      |                          ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:3005:13
[INFO] [stdout]      |
[INFO] [stdout] 3005 | /             syntax_error!(
[INFO] [stdout] 3006 | |                 self,
[INFO] [stdout] 3007 | |                 Span::new_with_checked(expr_start, self.last_pos()),
[INFO] [stdout] 3008 | |                 SyntaxError::EmptyParenExpr
[INFO] [stdout] 3009 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:3020:22
[INFO] [stdout]      |
[INFO] [stdout] 3020 |                 } => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),
[INFO] [stdout]      |                      ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:3037:26
[INFO] [stdout]      |
[INFO] [stdout] 3037 |                     } => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),
[INFO] [stdout]      |                          ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:3128:21
[INFO] [stdout]      |
[INFO] [stdout] 3128 |                       expect!(p, Token::Arrow);
[INFO] [stdout]      |                       ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/expr.rs:3206:13
[INFO] [stdout]      |
[INFO] [stdout] 3206 |             syntax_error!(self, self.input().cur_span(), SyntaxError::TS1109)
[INFO] [stdout]      |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:18:17
[INFO] [stdout]    |
[INFO] [stdout] 18 |                 syntax_error!(self, name.span, SyntaxError::InvalidModuleExportName)
[INFO] [stdout]    |                 -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:24:13
[INFO] [stdout]    |
[INFO] [stdout] 24 |               unexpected!(self, "identifier or string");
[INFO] [stdout]    |               ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:40:13
[INFO] [stdout]    |
[INFO] [stdout] 40 |             syntax_error!(self, SyntaxError::ExpectedIdent)
[INFO] [stdout]    |             ----------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |           return Err(err.into());
[INFO] [stdout]    |                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:59:13
[INFO] [stdout]    |
[INFO] [stdout] 59 | /             syntax_error!(
[INFO] [stdout] 60 | |                 self,
[INFO] [stdout] 61 | |                 self.span(start),
[INFO] [stdout] 62 | |                 SyntaxError::SpaceBetweenHashAndIdent
[INFO] [stdout] 63 | |             );
[INFO] [stdout]    | |_____________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:96:13
[INFO] [stdout]    |
[INFO] [stdout] 96 |               unexpected!(self, "let is reserved in const, let, class declaration")
[INFO] [stdout]    |               --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:146:13
[INFO] [stdout]     |
[INFO] [stdout] 146 |             syntax_error!(self, SyntaxError::ExpectedIdent)
[INFO] [stdout]     |             ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:185:17
[INFO] [stdout]     |
[INFO] [stdout] 185 |                 syntax_error!(self, span, SyntaxError::ExpectedIdent)
[INFO] [stdout]     |                 ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:189:17
[INFO] [stdout]     |
[INFO] [stdout] 189 |                 syntax_error!(self, span, SyntaxError::InvalidIdentInAsync)
[INFO] [stdout]     |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:197:17
[INFO] [stdout]     |
[INFO] [stdout] 197 |                 syntax_error!(self, span, SyntaxError::ExpectedIdent)
[INFO] [stdout]     |                 ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/ident.rs:215:13
[INFO] [stdout]     |
[INFO] [stdout] 215 |             syntax_error!(self, span, SyntaxError::ExpectedIdent)
[INFO] [stdout]     |             ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:32:9
[INFO] [stdout]    |
[INFO] [stdout] 32 |           expect!(self, Token::RBrace);
[INFO] [stdout]    |           ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:57:17
[INFO] [stdout]    |
[INFO] [stdout] 57 |                 syntax_error!(self, self.span(start), SyntaxError::EmptyJSXAttr)
[INFO] [stdout]    |                 ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |           return Err(err.into());
[INFO] [stdout]    |                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:84:17
[INFO] [stdout]    |
[INFO] [stdout] 84 | /                 syntax_error!(
[INFO] [stdout] 85 | |                     self,
[INFO] [stdout] 86 | |                     self.input().cur_span(),
[INFO] [stdout] 87 | |                     SyntaxError::InvalidUnicodeEscape
[INFO] [stdout] 88 | |                 );
[INFO] [stdout]    | |_________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:95:13
[INFO] [stdout]    |
[INFO] [stdout] 95 |               unexpected!(self, "jsx identifier")
[INFO] [stdout]    |               ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |           return Err(err.into());
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:168:13
[INFO] [stdout]     |
[INFO] [stdout] 168 | /             syntax_error!(
[INFO] [stdout] 169 | |                 self,
[INFO] [stdout] 170 | |                 tagname.span(),
[INFO] [stdout] 171 | |                 SyntaxError::JSXExpectedClosingTag {
[INFO] [stdout] ...   |
[INFO] [stdout] 174 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:282:17
[INFO] [stdout]     |
[INFO] [stdout] 282 |                   unexpected!(self, "< (jsx tag start), jsx text or {")
[INFO] [stdout]     |                   ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/jsx.rs:340:21
[INFO] [stdout]     |
[INFO] [stdout] 340 |                     syntax_error!(self, span, SyntaxError::InvalidJSXValue)
[INFO] [stdout]     |                     ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:34:17
[INFO] [stdout]    |
[INFO] [stdout] 34 |                 syntax_error!(self, attributes.span, SyntaxError::InvalidImportAttributes)
[INFO] [stdout]    |                 -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:37:17
[INFO] [stdout]    |
[INFO] [stdout] 37 |                 syntax_error!(self, attributes.span, SyntaxError::InvalidImportAttributes)
[INFO] [stdout]    |                 -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:42:22
[INFO] [stdout]    |
[INFO] [stdout] 42 |                 _ => syntax_error!(self, attributes.span, SyntaxError::InvalidImportAttributes),
[INFO] [stdout]    |                      -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout] 33 |         return Err(err.into());
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:45:17
[INFO] [stdout]    |
[INFO] [stdout] 45 |                 syntax_error!(self, attributes.span, SyntaxError::InvalidImportAttributes)
[INFO] [stdout]    |                 -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:53:9
[INFO] [stdout]    |
[INFO] [stdout] 53 |           expect!(self, Token::From);
[INFO] [stdout]    |           -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:59:13
[INFO] [stdout]    |
[INFO] [stdout] 59 |               unexpected!(self, "a string literal")
[INFO] [stdout]    |               ------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |           return Err(err.into());
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:210:37
[INFO] [stdout]     |
[INFO] [stdout] 210 | / ...                   syntax_error!(
[INFO] [stdout] 211 | | ...                       self,
[INFO] [stdout] 212 | | ...                       s.span,
[INFO] [stdout] 213 | | ...                       SyntaxError::ImportBindingIsString(
[INFO] [stdout] ...   |
[INFO] [stdout] 216 | | ...                   )
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:255:25
[INFO] [stdout]     |
[INFO] [stdout] 255 |                           expect!(self, Token::As);
[INFO] [stdout]     |                           ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |           return Err(err.into());
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:277:37
[INFO] [stdout]     |
[INFO] [stdout] 277 | / ...                   syntax_error!(
[INFO] [stdout] 278 | | ...                       self,
[INFO] [stdout] 279 | | ...                       possibly_orig_name.span,
[INFO] [stdout] 280 | | ...                       SyntaxError::ReservedWordInImport
[INFO] [stdout] 281 | | ...                   )
[INFO] [stdout]     | |_______________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:368:21
[INFO] [stdout]     |
[INFO] [stdout] 368 |                     syntax_error!(self, orig_name.span, SyntaxError::ReservedWordInImport)
[INFO] [stdout]     |                     ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |           return Err(err.into());
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:392:21
[INFO] [stdout]     |
[INFO] [stdout] 392 | /                     syntax_error!(
[INFO] [stdout] 393 | |                         self,
[INFO] [stdout] 394 | |                         orig_str.span,
[INFO] [stdout] 395 | |                         SyntaxError::ImportBindingIsString(orig_str.value.to_string_lossy().into())
[INFO] [stdout] 396 | |                     )
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:484:17
[INFO] [stdout]     |
[INFO] [stdout] 484 |                   expect!(self, Token::Namespace);
[INFO] [stdout]     |                   ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:508:21
[INFO] [stdout]     |
[INFO] [stdout] 508 |                     syntax_error!(self, self.span(start), SyntaxError::TS8038);
[INFO] [stdout]     |                     ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:637:17
[INFO] [stdout]     |
[INFO] [stdout] 637 |                 syntax_error!(self, self.span(start), SyntaxError::TS8038);
[INFO] [stdout]     |                 ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:771:17
[INFO] [stdout]     |
[INFO] [stdout] 771 |                   expect!(self, Token::As);
[INFO] [stdout]     |                   ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:801:21
[INFO] [stdout]     |
[INFO] [stdout] 801 |                       expect!(self, Token::From);
[INFO] [stdout]     |                       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:804:17
[INFO] [stdout]     |
[INFO] [stdout] 804 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:807:13
[INFO] [stdout]     |
[INFO] [stdout] 807 |               expect!(self, Token::LBrace);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:816:21
[INFO] [stdout]     |
[INFO] [stdout] 816 |                       expect!(self, Token::Comma);
[INFO] [stdout]     |                       --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:819:13
[INFO] [stdout]     |
[INFO] [stdout] 819 |               expect!(self, Token::RBrace);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:921:9
[INFO] [stdout]     |
[INFO] [stdout] 921 |           expect!(self, Token::Import);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1034:21
[INFO] [stdout]      |
[INFO] [stdout] 1034 |                       expect!(self, Token::Comma);
[INFO] [stdout]      |                       --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1052:17
[INFO] [stdout]      |
[INFO] [stdout] 1052 |                   expect!(self, Token::As);
[INFO] [stdout]      |                   ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1069:25
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                           expect!(self, Token::Comma);
[INFO] [stdout]      |                           --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1072:17
[INFO] [stdout]      |
[INFO] [stdout] 1072 |                   expect!(self, Token::RBrace);
[INFO] [stdout]      |                   ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1077:13
[INFO] [stdout]      |
[INFO] [stdout] 1077 |               expect!(self, Token::From);
[INFO] [stdout]      |               -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1081:17
[INFO] [stdout]      |
[INFO] [stdout] 1081 |                   unexpected!(self, "a string literal")
[INFO] [stdout]      |                   ------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/module_item.rs:1109:9
[INFO] [stdout]      |
[INFO] [stdout] 1109 |         syntax_error!(p, SyntaxError::NonTopLevelImportExport);
[INFO] [stdout]      |         ------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:33:21
[INFO] [stdout]    |
[INFO] [stdout] 33 |                       expect!(p, Token::Comma);
[INFO] [stdout]    |                       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:71:18
[INFO] [stdout]    |
[INFO] [stdout] 71 |               _ => unexpected!(self, "an identifier"),
[INFO] [stdout]    |                    ---------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:135:30
[INFO] [stdout]     |
[INFO] [stdout] 135 |                         _ => syntax_error!(self, prop.span(), SyntaxError::DotsWithoutIdentifier),
[INFO] [stdout]     |                              -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:298:18
[INFO] [stdout]     |
[INFO] [stdout] 298 |               _ => unexpected!(self, "identifier"),
[INFO] [stdout]     |                    ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:477:21
[INFO] [stdout]     |
[INFO] [stdout] 477 | /                     unexpected!(
[INFO] [stdout] 478 | |                         self,
[INFO] [stdout] 479 | |                         "... , *,  (, [, :, , ?, =, an identifier, public, protected, private, \
[INFO] [stdout] 480 | |                          readonly, <."
[INFO] [stdout] 481 | |                     )
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/object.rs:483:21
[INFO] [stdout]     |
[INFO] [stdout] 483 |                       unexpected!(self, "... , *,  (, [, :, , ?, = or an identifier")
[INFO] [stdout]     |                       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:337:42
[INFO] [stdout]     |
[INFO] [stdout] 337 | ...                   _ => syntax_error!(self, prop.span(), SyntaxError::InvalidPat),
[INFO] [stdout]     |                            --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:556:13
[INFO] [stdout]     |
[INFO] [stdout] 556 |               unexpected!(self, "yield, an identifier, [ or {")
[INFO] [stdout]     |               ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:601:17
[INFO] [stdout]     |
[INFO] [stdout] 601 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:608:9
[INFO] [stdout]     |
[INFO] [stdout] 608 |           expect!(self, Token::RBracket);
[INFO] [stdout]     |           ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |           return Err(err.into());
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:671:25
[INFO] [stdout]     |
[INFO] [stdout] 671 | /                         syntax_error!(
[INFO] [stdout] 672 | |                             self,
[INFO] [stdout] 673 | |                             self.input().prev_span(),
[INFO] [stdout] 674 | |                             SyntaxError::TsBindingPatCannotBeOptional
[INFO] [stdout] 675 | |                         );
[INFO] [stdout]     | |_________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:789:25
[INFO] [stdout]     |
[INFO] [stdout] 789 |                 node => syntax_error!(self, node.span(), SyntaxError::TsInvalidParamPropPat),
[INFO] [stdout]     |                         -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:847:17
[INFO] [stdout]     |
[INFO] [stdout] 847 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/pat.rs:946:17
[INFO] [stdout]     |
[INFO] [stdout] 946 |                   expect!(self, Token::Comma);
[INFO] [stdout]     |                   --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]    |
[INFO] [stdout] 10 | / macro_rules! syntax_error {
[INFO] [stdout] 11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout] 12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout] 13 | |     };
[INFO] [stdout] ...  |
[INFO] [stdout] 33 | |         return Err(err.into());
[INFO] [stdout]    | |                    ^^^^^^^^^^
[INFO] [stdout] 34 | |     }};
[INFO] [stdout] 35 | | }
[INFO] [stdout]    | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]    |
[INFO] [stdout]   ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:77:13
[INFO] [stdout]    |
[INFO] [stdout] 77 |               expect!(self, Token::Semi);
[INFO] [stdout]    |               -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:202:29
[INFO] [stdout]     |
[INFO] [stdout] 202 | ...                   syntax_error!(self, self.span(start), SyntaxError::PatVarWithoutInit)
[INFO] [stdout]     |                       --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:246:21
[INFO] [stdout]     |
[INFO] [stdout] 246 |                       expect!(p, Token::RParen);
[INFO] [stdout]     |                       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:452:13
[INFO] [stdout]     |
[INFO] [stdout] 452 |               expect!(self, Token::Semi);
[INFO] [stdout]     |               -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:492:13
[INFO] [stdout]     |
[INFO] [stdout] 492 |               expect!(self, Token::Semi);
[INFO] [stdout]     |               -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:568:9
[INFO] [stdout]     |
[INFO] [stdout] 568 |           expect!(self, Token::Semi);
[INFO] [stdout]     |           -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:587:9
[INFO] [stdout]     |
[INFO] [stdout] 587 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:597:9
[INFO] [stdout]     |
[INFO] [stdout] 597 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:610:21
[INFO] [stdout]     |
[INFO] [stdout] 610 |                     syntax_error!(self, await_token, SyntaxError::AwaitForStmt);
[INFO] [stdout]     |                     ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:628:21
[INFO] [stdout]     |
[INFO] [stdout] 628 |                     syntax_error!(self, await_token, SyntaxError::AwaitForStmt);
[INFO] [stdout]     |                     ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:651:21
[INFO] [stdout]     |
[INFO] [stdout] 651 |                     syntax_error!(self, await_token, SyntaxError::AwaitForStmt);
[INFO] [stdout]     |                     ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:708:9
[INFO] [stdout]     |
[INFO] [stdout] 708 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:725:9
[INFO] [stdout]     |
[INFO] [stdout] 725 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:807:13
[INFO] [stdout]     |
[INFO] [stdout] 807 |             syntax_error!(self, SyntaxError::LineBreakInThrow);
[INFO] [stdout]     |             -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:832:9
[INFO] [stdout]     |
[INFO] [stdout] 832 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:834:9
[INFO] [stdout]     |
[INFO] [stdout] 834 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:851:9
[INFO] [stdout]     |
[INFO] [stdout] 851 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:853:9
[INFO] [stdout]     |
[INFO] [stdout] 853 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:894:13
[INFO] [stdout]     |
[INFO] [stdout] 894 |               expect!(self, Token::RParen);
[INFO] [stdout]     |               ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:913:9
[INFO] [stdout]     |
[INFO] [stdout] 913 |           expect!(self, Token::While);
[INFO] [stdout]     |           --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:914:9
[INFO] [stdout]     |
[INFO] [stdout] 914 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:918:9
[INFO] [stdout]     |
[INFO] [stdout] 918 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1011:9
[INFO] [stdout]      |
[INFO] [stdout] 1011 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1081:9
[INFO] [stdout]      |
[INFO] [stdout] 1081 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1083:9
[INFO] [stdout]      |
[INFO] [stdout] 1083 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1088:9
[INFO] [stdout]      |
[INFO] [stdout] 1088 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1103:25
[INFO] [stdout]      |
[INFO] [stdout] 1103 |                         syntax_error!(p, SyntaxError::MultipleDefault { previous });
[INFO] [stdout]      |                         ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1109:17
[INFO] [stdout]      |
[INFO] [stdout] 1109 |                   expect!(p, Token::Colon);
[INFO] [stdout]      |                   ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1131:9
[INFO] [stdout]      |
[INFO] [stdout] 1131 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1453:13
[INFO] [stdout]      |
[INFO] [stdout] 1453 |               unexpected!(self, "const, let or var")
[INFO] [stdout]      |               -------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1482:17
[INFO] [stdout]      |
[INFO] [stdout] 1482 |                   expect!(self, Token::RBracket);
[INFO] [stdout]      |                   ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1501:9
[INFO] [stdout]      |
[INFO] [stdout] 1501 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1553:13
[INFO] [stdout]      |
[INFO] [stdout] 1553 |               expect!(self, Token::Comma);
[INFO] [stdout]      |               --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1559:9
[INFO] [stdout]      |
[INFO] [stdout] 1559 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1564:9
[INFO] [stdout]      |
[INFO] [stdout] 1564 |           expect!(self, Token::LBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1587:17
[INFO] [stdout]      |
[INFO] [stdout] 1587 |                   expect!(self, Token::Comma);
[INFO] [stdout]      |                   --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1599:13
[INFO] [stdout]      |
[INFO] [stdout] 1599 |               expect!(self, Token::Comma);
[INFO] [stdout]      |               --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1605:9
[INFO] [stdout]      |
[INFO] [stdout] 1605 |           expect!(self, Token::RBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1615:13
[INFO] [stdout]      |
[INFO] [stdout] 1615 |               expect!(self, Token::RParen);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1646:17
[INFO] [stdout]      |
[INFO] [stdout] 1646 |                   unexpected!(self, "numeric or bigint literal")
[INFO] [stdout]      |                   ---------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1669:9
[INFO] [stdout]      |
[INFO] [stdout] 1669 |           unexpected!(self, "a pattern")
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1704:9
[INFO] [stdout]      |
[INFO] [stdout] 1704 |         syntax_error!(self, span, SyntaxError::Expected(": or =>".into(), cur))
[INFO] [stdout]      |         ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1810:9
[INFO] [stdout]      |
[INFO] [stdout] 1810 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1856:9
[INFO] [stdout]      |
[INFO] [stdout] 1856 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1864:9
[INFO] [stdout]      |
[INFO] [stdout] 1864 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:1918:9
[INFO] [stdout]      |
[INFO] [stdout] 1918 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:2275:13
[INFO] [stdout]      |
[INFO] [stdout] 2275 | /             syntax_error!(
[INFO] [stdout] 2276 | |                 self,
[INFO] [stdout] 2277 | |                 SyntaxError::ExpectedSemiForExprStmt { expr: expr.span() }
[INFO] [stdout] 2278 | |             );
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/stmt.rs:2379:5
[INFO] [stdout]      |
[INFO] [stdout] 2379 |     syntax_error!(p, SyntaxError::ImportExportInScript);
[INFO] [stdout]      |     --------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:298:13
[INFO] [stdout]     |
[INFO] [stdout] 298 |               unexpected!(self, "identifier or string literal for a component prop")
[INFO] [stdout]     |               ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:358:9
[INFO] [stdout]     |
[INFO] [stdout] 358 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:372:13
[INFO] [stdout]     |
[INFO] [stdout] 372 |               expect!(self, Token::Comma);
[INFO] [stdout]     |               --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:378:9
[INFO] [stdout]     |
[INFO] [stdout] 378 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:536:9
[INFO] [stdout]     |
[INFO] [stdout] 536 |           expect!(self, Token::LParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:554:13
[INFO] [stdout]     |
[INFO] [stdout] 554 |               expect!(self, Token::Comma);
[INFO] [stdout]     |               --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:560:9
[INFO] [stdout]     |
[INFO] [stdout] 560 |           expect!(self, Token::RParen);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:583:9
[INFO] [stdout]     |
[INFO] [stdout] 583 |           expect!(self, Token::From);
[INFO] [stdout]     |           -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:589:13
[INFO] [stdout]     |
[INFO] [stdout] 589 |               unexpected!(self, "a string literal")
[INFO] [stdout]     |               ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:602:13
[INFO] [stdout]     |
[INFO] [stdout] 602 |               unexpected!(self, "an identifier or string literal")
[INFO] [stdout]     |               ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:623:9
[INFO] [stdout]     |
[INFO] [stdout] 623 |           expect!(self, Token::LBrace);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:630:9
[INFO] [stdout]     |
[INFO] [stdout] 630 |           expect!(self, Token::RBrace);
[INFO] [stdout]     |           ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | / macro_rules! syntax_error {
[INFO] [stdout]  11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]  12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]  13 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  33 | |         return Err(err.into());
[INFO] [stdout]     | |                    ^^^^^^^^^^
[INFO] [stdout]  34 | |     }};
[INFO] [stdout]  35 | | }
[INFO] [stdout]     | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:771:13
[INFO] [stdout]     |
[INFO] [stdout] 771 |               expect!(self, Token::Comma);
[INFO] [stdout]     |               --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1045:17
[INFO] [stdout]      |
[INFO] [stdout] 1045 |                   expect!(self, Token::LBracket);
[INFO] [stdout]      |                   ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1047:17
[INFO] [stdout]      |
[INFO] [stdout] 1047 |                   expect!(self, Token::Lt);
[INFO] [stdout]      |                   ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1052:13
[INFO] [stdout]      |
[INFO] [stdout] 1052 |               expect!(self, Token::RBracket);
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1054:13
[INFO] [stdout]      |
[INFO] [stdout] 1054 |               expect!(self, Token::Gt);
[INFO] [stdout]      |               ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1062:9
[INFO] [stdout]      |
[INFO] [stdout] 1062 |           expect!(self, Token::This);
[INFO] [stdout]      |           -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1128:21
[INFO] [stdout]      |
[INFO] [stdout] 1128 |                       expect!(p, Token::Lt);
[INFO] [stdout]      |                       --------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1286:17
[INFO] [stdout]      |
[INFO] [stdout] 1286 | /                 syntax_error!(
[INFO] [stdout] 1287 | |                     p,
[INFO] [stdout] 1288 | |                     p.input().cur_span(),
[INFO] [stdout] 1289 | |                     SyntaxError::Unexpected {
[INFO] [stdout] ...    |
[INFO] [stdout] 1293 | |                 );
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1499:21
[INFO] [stdout]      |
[INFO] [stdout] 1499 |                       unexpected!(p, "< (jsx tag start)")
[INFO] [stdout]      |                       ----------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 |   macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |           return Err(err.into());
[INFO] [stdout]      |                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1567:17
[INFO] [stdout]      |
[INFO] [stdout] 1567 | /                 syntax_error!(
[INFO] [stdout] 1568 | |                     p,
[INFO] [stdout] 1569 | |                     span,
[INFO] [stdout] 1570 | |                     SyntaxError::Expected(format!("{return_token:?}"), cur)
[INFO] [stdout] 1571 | |                 )
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1578:21
[INFO] [stdout]      |
[INFO] [stdout] 1578 |                       unexpected!(p, "checks");
[INFO] [stdout]      |                       ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1586:21
[INFO] [stdout]      |
[INFO] [stdout] 1586 |                       expect!(p, Token::RParen);
[INFO] [stdout]      |                       ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:1975:9
[INFO] [stdout]      |
[INFO] [stdout] 1975 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2026:9
[INFO] [stdout]      |
[INFO] [stdout] 2026 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2146:9
[INFO] [stdout]      |
[INFO] [stdout] 2146 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2149:9
[INFO] [stdout]      |
[INFO] [stdout] 2149 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2186:9
[INFO] [stdout]      |
[INFO] [stdout] 2186 |           expect!(self, Token::BackQuote);
[INFO] [stdout]      |           ------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2209:13
[INFO] [stdout]      |
[INFO] [stdout] 2209 |               expect!(self, Token::DollarLBrace);
[INFO] [stdout]      |               ---------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2211:13
[INFO] [stdout]      |
[INFO] [stdout] 2211 |               expect!(self, Token::RBrace);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2473:9
[INFO] [stdout]      |
[INFO] [stdout] 2473 |           expect!(self, Token::LBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2482:13
[INFO] [stdout]      |
[INFO] [stdout] 2482 |               expect!(self, Token::Colon);
[INFO] [stdout]      |               --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2489:9
[INFO] [stdout]      |
[INFO] [stdout] 2489 |           expect!(self, Token::RBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2528:9
[INFO] [stdout]      |
[INFO] [stdout] 2528 |           expect!(self, Token::LBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2532:9
[INFO] [stdout]      |
[INFO] [stdout] 2532 |           expect!(self, Token::RBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2571:9
[INFO] [stdout]      |
[INFO] [stdout] 2571 |           expect!(self, Token::Require);
[INFO] [stdout]      |           ----------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2572:9
[INFO] [stdout]      |
[INFO] [stdout] 2572 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2578:13
[INFO] [stdout]      |
[INFO] [stdout] 2578 |               unexpected!(self, "a string literal")
[INFO] [stdout]      |               ------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2581:9
[INFO] [stdout]      |
[INFO] [stdout] 2581 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2598:9
[INFO] [stdout]      |
[INFO] [stdout] 2598 |           expect!(self, Token::Eq);
[INFO] [stdout]      |           ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2636:22
[INFO] [stdout]      |
[INFO] [stdout] 2636 |                   _ => unexpected!(
[INFO] [stdout]      |  ______________________-
[INFO] [stdout] 2637 | |                     p,
[INFO] [stdout] 2638 | |                     "an identifier, [ for an array pattern, { for an object patter or ... for a \
[INFO] [stdout] 2639 | |                      rest pattern"
[INFO] [stdout] 2640 | |                 ),
[INFO] [stdout]      | |_________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2717:21
[INFO] [stdout]      |
[INFO] [stdout] 2717 |                       expect!(self, Token::Comma);
[INFO] [stdout]      |                       --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2724:13
[INFO] [stdout]      |
[INFO] [stdout] 2724 |               expect!(self, Token::RParen);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2734:9
[INFO] [stdout]      |
[INFO] [stdout] 2734 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2771:13
[INFO] [stdout]      |
[INFO] [stdout] 2771 |               expect!(self, Token::New);
[INFO] [stdout]      |               ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2776:9
[INFO] [stdout]      |
[INFO] [stdout] 2776 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2833:13
[INFO] [stdout]      |
[INFO] [stdout] 2833 |               expect!(p, Token::Colon);
[INFO] [stdout]      |               ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2979:21
[INFO] [stdout]      |
[INFO] [stdout] 2979 |                     syntax_error!(self, self.span(start), SyntaxError::TsRequiredAfterOptional)
[INFO] [stdout]      |                     --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:2996:9
[INFO] [stdout]      |
[INFO] [stdout] 2996 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3006:13
[INFO] [stdout]      |
[INFO] [stdout] 3006 |               expect!(self, Token::Readonly)
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3011:9
[INFO] [stdout]      |
[INFO] [stdout] 3011 |           expect!(self, Token::LBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3018:9
[INFO] [stdout]      |
[INFO] [stdout] 3018 |           expect!(self, Token::RBracket);
[INFO] [stdout]      |           ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3029:13
[INFO] [stdout]      |
[INFO] [stdout] 3029 |               expect!(self, Token::QuestionMark);
[INFO] [stdout]      |               ---------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3040:9
[INFO] [stdout]      |
[INFO] [stdout] 3040 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3058:9
[INFO] [stdout]      |
[INFO] [stdout] 3058 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3064:9
[INFO] [stdout]      |
[INFO] [stdout] 3064 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3115:9
[INFO] [stdout]      |
[INFO] [stdout] 3115 |           expect!(self, Token::Type);
[INFO] [stdout]      |           -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3163:13
[INFO] [stdout]      |
[INFO] [stdout] 3163 |               expect!(self, Token::New);
[INFO] [stdout]      |               ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3168:9
[INFO] [stdout]      |
[INFO] [stdout] 3168 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3356:9
[INFO] [stdout]      |
[INFO] [stdout] 3356 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3396:9
[INFO] [stdout]      |
[INFO] [stdout] 3396 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3503:41
[INFO] [stdout]      |
[INFO] [stdout] 3503 |               TsTypeOperatorOp::Unique => expect!(self, Token::Unique),
[INFO] [stdout]      |                                           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3504:40
[INFO] [stdout]      |
[INFO] [stdout] 3504 |               TsTypeOperatorOp::KeyOf => expect!(self, Token::Keyof),
[INFO] [stdout]      |                                          --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3505:43
[INFO] [stdout]      |
[INFO] [stdout] 3505 |               TsTypeOperatorOp::ReadOnly => expect!(self, Token::Readonly),
[INFO] [stdout]      |                                             ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3523:9
[INFO] [stdout]      |
[INFO] [stdout] 3523 |           expect!(self, Token::Infer);
[INFO] [stdout]      |           --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3526:13
[INFO] [stdout]      |
[INFO] [stdout] 3526 |               expect!(p, Token::Extends);
[INFO] [stdout]      |               -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3630:17
[INFO] [stdout]      |
[INFO] [stdout] 3630 |                   expect!(self, Token::RBracket);
[INFO] [stdout]      |                   ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3688:13
[INFO] [stdout]      |
[INFO] [stdout] 3688 |               expect!(p, Token::QuestionMark);
[INFO] [stdout]      |               ------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3692:13
[INFO] [stdout]      |
[INFO] [stdout] 3692 |               expect!(p, Token::Colon);
[INFO] [stdout]      |               ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3719:17
[INFO] [stdout]      |
[INFO] [stdout] 3719 |                   unexpected!(self, "identifier");
[INFO] [stdout]      |                   ------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3733:13
[INFO] [stdout]      |
[INFO] [stdout] 3733 |               expect!(self, Token::RBracket);
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3781:17
[INFO] [stdout]      |
[INFO] [stdout] 3781 |                 syntax_error!(self, SyntaxError::ReadOnlyMethod);
[INFO] [stdout]      |                 ------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3785:13
[INFO] [stdout]      |
[INFO] [stdout] 3785 |               expect!(self, Token::LParen);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3865:17
[INFO] [stdout]      |
[INFO] [stdout] 3865 |                   expect!(p, Token::LBracket);
[INFO] [stdout]      |                   --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3867:17
[INFO] [stdout]      |
[INFO] [stdout] 3867 |                   expect!(p, Token::RBracket);
[INFO] [stdout]      |                   --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3942:17
[INFO] [stdout]      |
[INFO] [stdout] 3942 |                 syntax_error!(p, SyntaxError::GetterSetterCannotBeReadonly)
[INFO] [stdout]      |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3948:17
[INFO] [stdout]      |
[INFO] [stdout] 3948 |                   expect!(p, Token::Set);
[INFO] [stdout]      |                   ---------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3955:17
[INFO] [stdout]      |
[INFO] [stdout] 3955 |                   expect!(p, Token::LParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3956:17
[INFO] [stdout]      |
[INFO] [stdout] 3956 |                   expect!(p, Token::RParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3968:17
[INFO] [stdout]      |
[INFO] [stdout] 3968 |                   expect!(p, Token::LParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]   33 |         return Err(err.into());
[INFO] [stdout]      |                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:3971:21
[INFO] [stdout]      |
[INFO] [stdout] 3971 |                     syntax_error!(p, SyntaxError::SetterParamRequired)
[INFO] [stdout]      |                     -------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4008:9
[INFO] [stdout]      |
[INFO] [stdout] 4008 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4018:13
[INFO] [stdout]      |
[INFO] [stdout] 4018 |               expect!(self, Token::RBrace);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4031:17
[INFO] [stdout]      |
[INFO] [stdout] 4031 |                   expect!(p, Token::Pipe);
[INFO] [stdout]      |                   ----------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4068:9
[INFO] [stdout]      |
[INFO] [stdout] 4068 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4163:9
[INFO] [stdout]      |
[INFO] [stdout] 4163 |           expect!(self, Token::Gt);
[INFO] [stdout]      |           ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4177:9
[INFO] [stdout]      |
[INFO] [stdout] 4177 |           expect!(self, Token::LParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4208:9
[INFO] [stdout]      |
[INFO] [stdout] 4208 |           expect!(self, Token::RParen);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4241:9
[INFO] [stdout]      |
[INFO] [stdout] 4241 |           expect!(self, Token::With);
[INFO] [stdout]      |           -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4242:9
[INFO] [stdout]      |
[INFO] [stdout] 4242 |           expect!(self, Token::Colon);
[INFO] [stdout]      |           --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4249:9
[INFO] [stdout]      |
[INFO] [stdout] 4249 |           expect!(self, Token::RBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4261:9
[INFO] [stdout]      |
[INFO] [stdout] 4261 |           expect!(self, Token::TypeOf);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4268:13
[INFO] [stdout]      |
[INFO] [stdout] 4268 |               expect!(self, Token::RParen);
[INFO] [stdout]      |               ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4301:9
[INFO] [stdout]      |
[INFO] [stdout] 4301 |           expect!(self, Token::LBrace);
[INFO] [stdout]      |           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4365:13
[INFO] [stdout]      |
[INFO] [stdout] 4365 |               unexpected!(self, "global or a string literal");
[INFO] [stdout]      |               ----------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4522:17
[INFO] [stdout]      |
[INFO] [stdout] 4522 |                   unexpected!(self, "numeric literal or bigint literal")
[INFO] [stdout]      |                   ------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:4660:9
[INFO] [stdout]      |
[INFO] [stdout] 4660 | /         unexpected!(
[INFO] [stdout] 4661 | |             self,
[INFO] [stdout] 4662 | |             "an identifier, void, yield, null, await, break, a string literal, a numeric literal, \
[INFO] [stdout] 4663 | |              true, false, `, -, import, this, typeof, {, [, ("
[INFO] [stdout] 4664 | |         )
[INFO] [stdout]      | |_________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:5101:25
[INFO] [stdout]      |
[INFO] [stdout] 5101 |                           unexpected!(self, "exports")
[INFO] [stdout]      |                           ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:5105:21
[INFO] [stdout]      |
[INFO] [stdout] 5105 |                       expect!(self, Token::Colon);
[INFO] [stdout]      |                       --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:5238:17
[INFO] [stdout]      |
[INFO] [stdout] 5238 |                   expect!(p, Token::LParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:5244:17
[INFO] [stdout]      |
[INFO] [stdout] 5244 |                   expect!(p, Token::RParen);
[INFO] [stdout]      |                   ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/typescript.rs:5254:17
[INFO] [stdout]      |
[INFO] [stdout] 5254 |                   expect!(p, Token::Arrow);
[INFO] [stdout]      |                   ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:947:13
[INFO] [stdout]     |
[INFO] [stdout] 947 |             syntax_error!(self, span, SyntaxError::Expected(";".to_string(), cur))
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:957:13
[INFO] [stdout]     |
[INFO] [stdout] 957 |             syntax_error!(self, span, SyntaxError::Expected(format!("{t:?}"), cur))
[INFO] [stdout]     |             ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]     |
[INFO] [stdout]  10 | macro_rules! syntax_error {
[INFO] [stdout] ...
[INFO] [stdout]  33 |         return Err(err.into());
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:968:13
[INFO] [stdout]     |
[INFO] [stdout] 968 |             syntax_error!(self, span, SyntaxError::Expected(format!("{t:?}"), cur))
[INFO] [stdout]     |             ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:1100:17
[INFO] [stdout]      |
[INFO] [stdout] 1100 |                   unexpected!(self, "identifier");
[INFO] [stdout]      |                   ------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `expect`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:1130:13
[INFO] [stdout]      |
[INFO] [stdout] 1130 |               expect!(self, Token::RBracket);
[INFO] [stdout]      |               ------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]     --> vendor/swc_ecma_parser-45.1.1/src/parser/macros.rs:33:20
[INFO] [stdout]      |
[INFO] [stdout]   10 | / macro_rules! syntax_error {
[INFO] [stdout]   11 | |     ($p:expr, $err:expr) => {
[INFO] [stdout]   12 | |         syntax_error!($p, $p.input().cur_span(), $err)
[INFO] [stdout]   13 | |     };
[INFO] [stdout] ...    |
[INFO] [stdout]   33 | |         return Err(err.into());
[INFO] [stdout]      | |                    ^^^^^^^^^^
[INFO] [stdout]   34 | |     }};
[INFO] [stdout]   35 | | }
[INFO] [stdout]      | |_- this error originates in the macro `syntax_error` which comes from the expansion of the macro `unexpected`
[INFO] [stdout]      |
[INFO] [stdout]     ::: vendor/swc_ecma_parser-45.1.1/src/parser/mod.rs:1136:13
[INFO] [stdout]      |
[INFO] [stdout] 1136 | /             unexpected!(
[INFO] [stdout] 1137 | |                 self,
[INFO] [stdout] 1138 | |                 "identifier, string literal, numeric literal or [ for the computed key"
[INFO] [stdout] 1139 | |             )
[INFO] [stdout]      | |_____________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `swc_ecma_parser` (lib) due to 296 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2", kill_on_drop: false }`
[INFO] [stdout] 664209cd977ceb9de2478b492cdd8705bf8f7baed3765ce87b66104a476fecb2
