[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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::into(val) to avoid triggering this lint [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `error::Error` [INFO] [stdout] --> 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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: you can instead use the fully-qualified path `::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