[INFO] fetching crate swc_next_ecma_ast 0.3.0...
[INFO] checking swc_next_ecma_ast-0.3.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate swc_next_ecma_ast 0.3.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate swc_next_ecma_ast 0.3.0
[INFO] finished tweaking crates.io crate swc_next_ecma_ast 0.3.0
[INFO] tweaked toml for crates.io crate swc_next_ecma_ast 0.3.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate swc_next_ecma_ast 0.3.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate swc_next_ecma_ast 0.3.0 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" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[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] 3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf
[INFO] running `Command { std: "docker" "start" "3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf", 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" "3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf", 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" "3380c3ebbe335d5a0fcc7426cb8c0231a2fefa6b12bd4384c9ad4feb52c92aaf" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling unicode-ident v1.0.20
[INFO] [stderr]     Checking allocator-api2 v0.2.21
[INFO] [stderr]     Checking oxc_index v5.0.0
[INFO] [stderr]     Checking unicode-id-start v1.5.0
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling syn v3.0.8
[INFO] [stderr]     Checking swc_next_allocator v0.3.0
[INFO] [stderr]    Compiling swc_next_ast_macros v0.3.0
[INFO] [stderr]     Checking swc_next_ecma_ast v0.3.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `js::BlockStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:34:30
[INFO] [stdout]    |
[INFO] [stdout] 34 |         Stmt::BlockStatement(self.block_statement(span, body).into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 34 -         Stmt::BlockStatement(self.block_statement(span, body).into())
[INFO] [stdout] 34 +         Stmt::BlockStatement(self.block_statement(span, body))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 -         Stmt::BlockStatement(self.block_statement(span, body).into())
[INFO] [stdout] 34 +         Stmt::BlockStatement(<js::BlockStatement as Into<_>>::into(self.block_statement(span, body)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BreakStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:38:30
[INFO] [stdout]    |
[INFO] [stdout] 38 |         Stmt::BreakStatement(self.break_statement(span, label).into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 38 -         Stmt::BreakStatement(self.break_statement(span, label).into())
[INFO] [stdout] 38 +         Stmt::BreakStatement(self.break_statement(span, label))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 -         Stmt::BreakStatement(self.break_statement(span, label).into())
[INFO] [stdout] 38 +         Stmt::BreakStatement(<js::BreakStatement as Into<_>>::into(self.break_statement(span, label)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ContinueStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:42:33
[INFO] [stdout]    |
[INFO] [stdout] 42 |         Stmt::ContinueStatement(self.continue_statement(span, label).into())
[INFO] [stdout]    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -         Stmt::ContinueStatement(self.continue_statement(span, label).into())
[INFO] [stdout] 42 +         Stmt::ContinueStatement(self.continue_statement(span, label))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -         Stmt::ContinueStatement(self.continue_statement(span, label).into())
[INFO] [stdout] 42 +         Stmt::ContinueStatement(<js::ContinueStatement as Into<_>>::into(self.continue_statement(span, label)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::DebuggerStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:46:33
[INFO] [stdout]    |
[INFO] [stdout] 46 |         Stmt::DebuggerStatement(self.debugger_statement(span).into())
[INFO] [stdout]    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 46 -         Stmt::DebuggerStatement(self.debugger_statement(span).into())
[INFO] [stdout] 46 +         Stmt::DebuggerStatement(self.debugger_statement(span))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 -         Stmt::DebuggerStatement(self.debugger_statement(span).into())
[INFO] [stdout] 46 +         Stmt::DebuggerStatement(<js::DebuggerStatement as Into<_>>::into(self.debugger_statement(span)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::DoWhileStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:50:32
[INFO] [stdout]    |
[INFO] [stdout] 50 |         Stmt::DoWhileStatement(self.do_while_statement(span, body, test).into())
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 50 -         Stmt::DoWhileStatement(self.do_while_statement(span, body, test).into())
[INFO] [stdout] 50 +         Stmt::DoWhileStatement(self.do_while_statement(span, body, test))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 -         Stmt::DoWhileStatement(self.do_while_statement(span, body, test).into())
[INFO] [stdout] 50 +         Stmt::DoWhileStatement(<js::DoWhileStatement as Into<_>>::into(self.do_while_statement(span, body, test)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::EmptyStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:54:30
[INFO] [stdout]    |
[INFO] [stdout] 54 |         Stmt::EmptyStatement(self.empty_statement(span).into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 54 -         Stmt::EmptyStatement(self.empty_statement(span).into())
[INFO] [stdout] 54 +         Stmt::EmptyStatement(self.empty_statement(span))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -         Stmt::EmptyStatement(self.empty_statement(span).into())
[INFO] [stdout] 54 +         Stmt::EmptyStatement(<js::EmptyStatement as Into<_>>::into(self.empty_statement(span)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ExpressionStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:58:35
[INFO] [stdout]    |
[INFO] [stdout] 58 |         Stmt::ExpressionStatement(self.expression_statement(span, expression).into())
[INFO] [stdout]    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 58 -         Stmt::ExpressionStatement(self.expression_statement(span, expression).into())
[INFO] [stdout] 58 +         Stmt::ExpressionStatement(self.expression_statement(span, expression))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -         Stmt::ExpressionStatement(self.expression_statement(span, expression).into())
[INFO] [stdout] 58 +         Stmt::ExpressionStatement(<js::ExpressionStatement as Into<_>>::into(self.expression_statement(span, expression)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ForInStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:68:30
[INFO] [stdout]    |
[INFO] [stdout] 68 |         Stmt::ForInStatement(self.for_in_statement(span, left, right, body).into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -         Stmt::ForInStatement(self.for_in_statement(span, left, right, body).into())
[INFO] [stdout] 68 +         Stmt::ForInStatement(self.for_in_statement(span, left, right, body))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -         Stmt::ForInStatement(self.for_in_statement(span, left, right, body).into())
[INFO] [stdout] 68 +         Stmt::ForInStatement(<js::ForInStatement as Into<_>>::into(self.for_in_statement(span, left, right, body)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ForOfStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:80:13
[INFO] [stdout]    |
[INFO] [stdout] 80 | /             self.for_of_statement(span, left, right, body, r#await)
[INFO] [stdout] 81 | |                 .into(),
[INFO] [stdout]    | |_______________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 80 -             self.for_of_statement(span, left, right, body, r#await)
[INFO] [stdout] 81 -                 .into(),
[INFO] [stdout] 80 +             self.for_of_statement(span, left, right, body, r#await),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 -             self.for_of_statement(span, left, right, body, r#await)
[INFO] [stdout] 81 -                 .into(),
[INFO] [stdout] 80 +             <js::ForOfStatement as Into<_>>::into(self.for_of_statement(span, left, right, body, r#await)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ForStatement`
[INFO] [stdout]   --> src/generated/ast_builder.rs:93:28
[INFO] [stdout]    |
[INFO] [stdout] 93 |         Stmt::ForStatement(self.for_statement(span, init, test, update, body).into())
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 93 -         Stmt::ForStatement(self.for_statement(span, init, test, update, body).into())
[INFO] [stdout] 93 +         Stmt::ForStatement(self.for_statement(span, init, test, update, body))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -         Stmt::ForStatement(self.for_statement(span, init, test, update, body).into())
[INFO] [stdout] 93 +         Stmt::ForStatement(<js::ForStatement as Into<_>>::into(self.for_statement(span, init, test, update, body)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IfStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:103:27
[INFO] [stdout]     |
[INFO] [stdout] 103 |         Stmt::IfStatement(self.if_statement(span, test, consequent, alternate).into())
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 103 -         Stmt::IfStatement(self.if_statement(span, test, consequent, alternate).into())
[INFO] [stdout] 103 +         Stmt::IfStatement(self.if_statement(span, test, consequent, alternate))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 -         Stmt::IfStatement(self.if_statement(span, test, consequent, alternate).into())
[INFO] [stdout] 103 +         Stmt::IfStatement(<js::IfStatement as Into<_>>::into(self.if_statement(span, test, consequent, alternate)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LabeledStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:112:32
[INFO] [stdout]     |
[INFO] [stdout] 112 |         Stmt::LabeledStatement(self.labeled_statement(span, label, body).into())
[INFO] [stdout]     |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 112 -         Stmt::LabeledStatement(self.labeled_statement(span, label, body).into())
[INFO] [stdout] 112 +         Stmt::LabeledStatement(self.labeled_statement(span, label, body))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 112 -         Stmt::LabeledStatement(self.labeled_statement(span, label, body).into())
[INFO] [stdout] 112 +         Stmt::LabeledStatement(<js::LabeledStatement as Into<_>>::into(self.labeled_statement(span, label, body)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ReturnStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:116:31
[INFO] [stdout]     |
[INFO] [stdout] 116 |         Stmt::ReturnStatement(self.return_statement(span, argument).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 116 -         Stmt::ReturnStatement(self.return_statement(span, argument).into())
[INFO] [stdout] 116 +         Stmt::ReturnStatement(self.return_statement(span, argument))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 -         Stmt::ReturnStatement(self.return_statement(span, argument).into())
[INFO] [stdout] 116 +         Stmt::ReturnStatement(<js::ReturnStatement as Into<_>>::into(self.return_statement(span, argument)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SwitchStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:125:31
[INFO] [stdout]     |
[INFO] [stdout] 125 |         Stmt::SwitchStatement(self.switch_statement(span, discriminant, cases).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 125 -         Stmt::SwitchStatement(self.switch_statement(span, discriminant, cases).into())
[INFO] [stdout] 125 +         Stmt::SwitchStatement(self.switch_statement(span, discriminant, cases))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 125 -         Stmt::SwitchStatement(self.switch_statement(span, discriminant, cases).into())
[INFO] [stdout] 125 +         Stmt::SwitchStatement(<js::SwitchStatement as Into<_>>::into(self.switch_statement(span, discriminant, cases)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThrowStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:129:30
[INFO] [stdout]     |
[INFO] [stdout] 129 |         Stmt::ThrowStatement(self.throw_statement(span, argument).into())
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 129 -         Stmt::ThrowStatement(self.throw_statement(span, argument).into())
[INFO] [stdout] 129 +         Stmt::ThrowStatement(self.throw_statement(span, argument))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 129 -         Stmt::ThrowStatement(self.throw_statement(span, argument).into())
[INFO] [stdout] 129 +         Stmt::ThrowStatement(<js::ThrowStatement as Into<_>>::into(self.throw_statement(span, argument)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TryStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:139:28
[INFO] [stdout]     |
[INFO] [stdout] 139 |         Stmt::TryStatement(self.try_statement(span, block, handler, finalizer).into())
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 139 -         Stmt::TryStatement(self.try_statement(span, block, handler, finalizer).into())
[INFO] [stdout] 139 +         Stmt::TryStatement(self.try_statement(span, block, handler, finalizer))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 -         Stmt::TryStatement(self.try_statement(span, block, handler, finalizer).into())
[INFO] [stdout] 139 +         Stmt::TryStatement(<js::TryStatement as Into<_>>::into(self.try_statement(span, block, handler, finalizer)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::WhileStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:143:30
[INFO] [stdout]     |
[INFO] [stdout] 143 |         Stmt::WhileStatement(self.while_statement(span, test, body).into())
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 143 -         Stmt::WhileStatement(self.while_statement(span, test, body).into())
[INFO] [stdout] 143 +         Stmt::WhileStatement(self.while_statement(span, test, body))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 -         Stmt::WhileStatement(self.while_statement(span, test, body).into())
[INFO] [stdout] 143 +         Stmt::WhileStatement(<js::WhileStatement as Into<_>>::into(self.while_statement(span, test, body)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::WithStatement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:147:29
[INFO] [stdout]     |
[INFO] [stdout] 147 |         Stmt::WithStatement(self.with_statement(span, object, body).into())
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 147 -         Stmt::WithStatement(self.with_statement(span, object, body).into())
[INFO] [stdout] 147 +         Stmt::WithStatement(self.with_statement(span, object, body))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 -         Stmt::WithStatement(self.with_statement(span, object, body).into())
[INFO] [stdout] 147 +         Stmt::WithStatement(<js::WithStatement as Into<_>>::into(self.with_statement(span, object, body)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::VariableDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:158:13
[INFO] [stdout]     |
[INFO] [stdout] 158 | /             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 159 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 158 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 159 -                 .into(),
[INFO] [stdout] 158 +             self.variable_declaration(span, kind, declarators, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 159 -                 .into(),
[INFO] [stdout] 158 +             <js::VariableDeclaration as Into<_>>::into(self.variable_declaration(span, kind, declarators, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]    --> src/generated/ast_builder.rs:177:13
[INFO] [stdout]     |
[INFO] [stdout] 177 | /             self.function(
[INFO] [stdout] 178 | |                 span,
[INFO] [stdout] 179 | |                 function_type,
[INFO] [stdout] 180 | |                 id,
[INFO] [stdout] ...   |
[INFO] [stdout] 189 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 188 -             )
[INFO] [stdout] 189 -             .into(),
[INFO] [stdout] 188 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 178 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 187 |                 r#async,
[INFO] [stdout] 188 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]    --> src/generated/ast_builder.rs:208:13
[INFO] [stdout]     |
[INFO] [stdout] 208 | /             self.class(
[INFO] [stdout] 209 | |                 span,
[INFO] [stdout] 210 | |                 class_type,
[INFO] [stdout] 211 | |                 decorators,
[INFO] [stdout] ...   |
[INFO] [stdout] 221 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 220 -             )
[INFO] [stdout] 221 -             .into(),
[INFO] [stdout] 220 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 209 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 219 |                 declare,
[INFO] [stdout] 220 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsFunction`
[INFO] [stdout]    --> src/generated/ast_builder.rs:238:13
[INFO] [stdout]     |
[INFO] [stdout] 238 | /             self.ts_function(
[INFO] [stdout] 239 | |                 span,
[INFO] [stdout] 240 | |                 id,
[INFO] [stdout] 241 | |                 type_parameters,
[INFO] [stdout] ...   |
[INFO] [stdout] 249 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 248 -             )
[INFO] [stdout] 249 -             .into(),
[INFO] [stdout] 248 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 ~             <ts::TsFunction as Into<_>>::into(self.ts_function(
[INFO] [stdout] 239 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 247 |                 declare,
[INFO] [stdout] 248 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAliasDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:262:13
[INFO] [stdout]     |
[INFO] [stdout] 262 | /             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 263 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 263 -                 .into(),
[INFO] [stdout] 262 +             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 263 -                 .into(),
[INFO] [stdout] 262 +             <ts::TsTypeAliasDeclaration as Into<_>>::into(self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInterfaceDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:277:13
[INFO] [stdout]     |
[INFO] [stdout] 277 | /             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 278 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 278 -                 .into(),
[INFO] [stdout] 277 +             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 278 -                 .into(),
[INFO] [stdout] 277 +             <ts::TsInterfaceDeclaration as Into<_>>::into(self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsEnumDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:291:13
[INFO] [stdout]     |
[INFO] [stdout] 291 | /             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 292 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 291 -             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 292 -                 .into(),
[INFO] [stdout] 291 +             self.ts_enum_declaration(span, id, body, is_const, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 -             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 292 -                 .into(),
[INFO] [stdout] 291 +             <ts::TsEnumDeclaration as Into<_>>::into(self.ts_enum_declaration(span, id, body, is_const, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsModuleDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:305:13
[INFO] [stdout]     |
[INFO] [stdout] 305 | /             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 306 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 305 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 306 -                 .into(),
[INFO] [stdout] 305 +             self.ts_module_declaration(span, id, body, kind, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 306 -                 .into(),
[INFO] [stdout] 305 +             <ts::TsModuleDeclaration as Into<_>>::into(self.ts_module_declaration(span, id, body, kind, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsGlobalDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:318:13
[INFO] [stdout]     |
[INFO] [stdout] 318 |             self.ts_global_declaration(span, id, body, declare).into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -             self.ts_global_declaration(span, id, body, declare).into(),
[INFO] [stdout] 318 +             self.ts_global_declaration(span, id, body, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -             self.ts_global_declaration(span, id, body, declare).into(),
[INFO] [stdout] 318 +             <ts::TsGlobalDeclaration as Into<_>>::into(self.ts_global_declaration(span, id, body, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsImportEqualsDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:330:13
[INFO] [stdout]     |
[INFO] [stdout] 330 | /             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 331 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 330 -             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 331 -                 .into(),
[INFO] [stdout] 330 +             self.ts_import_equals_declaration(span, id, module_reference, import_kind),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 -             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 331 -                 .into(),
[INFO] [stdout] 330 +             <ts::TsImportEqualsDeclaration as Into<_>>::into(self.ts_import_equals_declaration(span, id, module_reference, import_kind)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:345:13
[INFO] [stdout]     |
[INFO] [stdout] 345 | /             self.import_declaration(span, specifiers, source, attributes, phase, import_kind)
[INFO] [stdout] 346 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 345 -             self.import_declaration(span, specifiers, source, attributes, phase, import_kind)
[INFO] [stdout] 346 -                 .into(),
[INFO] [stdout] 345 +             self.import_declaration(span, specifiers, source, attributes, phase, import_kind),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 -             self.import_declaration(span, specifiers, source, attributes, phase, import_kind)
[INFO] [stdout] 346 -                 .into(),
[INFO] [stdout] 345 +             <js::ImportDeclaration as Into<_>>::into(self.import_declaration(span, specifiers, source, attributes, phase, import_kind)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ExportNamedDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:360:13
[INFO] [stdout]     |
[INFO] [stdout] 360 | /             self.export_named_declaration(
[INFO] [stdout] 361 | |                 span,
[INFO] [stdout] 362 | |                 declaration,
[INFO] [stdout] 363 | |                 specifiers,
[INFO] [stdout] ...   |
[INFO] [stdout] 368 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 367 -             )
[INFO] [stdout] 368 -             .into(),
[INFO] [stdout] 367 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 ~             <js::ExportNamedDeclaration as Into<_>>::into(self.export_named_declaration(
[INFO] [stdout] 361 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 366 |                 export_kind,
[INFO] [stdout] 367 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ExportDefaultDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:377:40
[INFO] [stdout]     |
[INFO] [stdout] 377 |         Stmt::ExportDefaultDeclaration(self.export_default_declaration(span, declaration).into())
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 377 -         Stmt::ExportDefaultDeclaration(self.export_default_declaration(span, declaration).into())
[INFO] [stdout] 377 +         Stmt::ExportDefaultDeclaration(self.export_default_declaration(span, declaration))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 -         Stmt::ExportDefaultDeclaration(self.export_default_declaration(span, declaration).into())
[INFO] [stdout] 377 +         Stmt::ExportDefaultDeclaration(<js::ExportDefaultDeclaration as Into<_>>::into(self.export_default_declaration(span, declaration)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ExportAllDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:389:13
[INFO] [stdout]     |
[INFO] [stdout] 389 | /             self.export_all_declaration(span, exported, source, attributes, export_kind)
[INFO] [stdout] 390 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 389 -             self.export_all_declaration(span, exported, source, attributes, export_kind)
[INFO] [stdout] 390 -                 .into(),
[INFO] [stdout] 389 +             self.export_all_declaration(span, exported, source, attributes, export_kind),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 -             self.export_all_declaration(span, exported, source, attributes, export_kind)
[INFO] [stdout] 390 -                 .into(),
[INFO] [stdout] 389 +             <js::ExportAllDeclaration as Into<_>>::into(self.export_all_declaration(span, exported, source, attributes, export_kind)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsExportAssignment`
[INFO] [stdout]    --> src/generated/ast_builder.rs:395:34
[INFO] [stdout]     |
[INFO] [stdout] 395 |         Stmt::TsExportAssignment(self.ts_export_assignment(span, expression).into())
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 395 -         Stmt::TsExportAssignment(self.ts_export_assignment(span, expression).into())
[INFO] [stdout] 395 +         Stmt::TsExportAssignment(self.ts_export_assignment(span, expression))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 395 -         Stmt::TsExportAssignment(self.ts_export_assignment(span, expression).into())
[INFO] [stdout] 395 +         Stmt::TsExportAssignment(<ts::TsExportAssignment as Into<_>>::into(self.ts_export_assignment(span, expression)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNamespaceExportDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:399:44
[INFO] [stdout]     |
[INFO] [stdout] 399 |         Stmt::TsNamespaceExportDeclaration(self.ts_namespace_export_declaration(span, id).into())
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 399 -         Stmt::TsNamespaceExportDeclaration(self.ts_namespace_export_declaration(span, id).into())
[INFO] [stdout] 399 +         Stmt::TsNamespaceExportDeclaration(self.ts_namespace_export_declaration(span, id))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 -         Stmt::TsNamespaceExportDeclaration(self.ts_namespace_export_declaration(span, id).into())
[INFO] [stdout] 399 +         Stmt::TsNamespaceExportDeclaration(<ts::TsNamespaceExportDeclaration as Into<_>>::into(self.ts_namespace_export_declaration(span, id)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::VariableDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:410:13
[INFO] [stdout]     |
[INFO] [stdout] 410 | /             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 411 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 410 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 411 -                 .into(),
[INFO] [stdout] 410 +             self.variable_declaration(span, kind, declarators, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 410 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 411 -                 .into(),
[INFO] [stdout] 410 +             <js::VariableDeclaration as Into<_>>::into(self.variable_declaration(span, kind, declarators, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]    --> src/generated/ast_builder.rs:429:13
[INFO] [stdout]     |
[INFO] [stdout] 429 | /             self.function(
[INFO] [stdout] 430 | |                 span,
[INFO] [stdout] 431 | |                 function_type,
[INFO] [stdout] 432 | |                 id,
[INFO] [stdout] ...   |
[INFO] [stdout] 441 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 440 -             )
[INFO] [stdout] 441 -             .into(),
[INFO] [stdout] 440 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 430 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 439 |                 r#async,
[INFO] [stdout] 440 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]    --> src/generated/ast_builder.rs:460:13
[INFO] [stdout]     |
[INFO] [stdout] 460 | /             self.class(
[INFO] [stdout] 461 | |                 span,
[INFO] [stdout] 462 | |                 class_type,
[INFO] [stdout] 463 | |                 decorators,
[INFO] [stdout] ...   |
[INFO] [stdout] 473 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 472 -             )
[INFO] [stdout] 473 -             .into(),
[INFO] [stdout] 472 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 460 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 461 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 471 |                 declare,
[INFO] [stdout] 472 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsFunction`
[INFO] [stdout]    --> src/generated/ast_builder.rs:490:13
[INFO] [stdout]     |
[INFO] [stdout] 490 | /             self.ts_function(
[INFO] [stdout] 491 | |                 span,
[INFO] [stdout] 492 | |                 id,
[INFO] [stdout] 493 | |                 type_parameters,
[INFO] [stdout] ...   |
[INFO] [stdout] 501 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 500 -             )
[INFO] [stdout] 501 -             .into(),
[INFO] [stdout] 500 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 490 ~             <ts::TsFunction as Into<_>>::into(self.ts_function(
[INFO] [stdout] 491 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 499 |                 declare,
[INFO] [stdout] 500 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAliasDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:514:13
[INFO] [stdout]     |
[INFO] [stdout] 514 | /             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 515 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 514 -             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 515 -                 .into(),
[INFO] [stdout] 514 +             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 514 -             self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)
[INFO] [stdout] 515 -                 .into(),
[INFO] [stdout] 514 +             <ts::TsTypeAliasDeclaration as Into<_>>::into(self.ts_type_alias_declaration(span, id, type_parameters, type_annotation, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInterfaceDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:529:13
[INFO] [stdout]     |
[INFO] [stdout] 529 | /             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 530 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 529 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 530 -                 .into(),
[INFO] [stdout] 529 +             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 530 -                 .into(),
[INFO] [stdout] 529 +             <ts::TsInterfaceDeclaration as Into<_>>::into(self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsEnumDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:543:13
[INFO] [stdout]     |
[INFO] [stdout] 543 | /             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 544 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 543 -             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 544 -                 .into(),
[INFO] [stdout] 543 +             self.ts_enum_declaration(span, id, body, is_const, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 543 -             self.ts_enum_declaration(span, id, body, is_const, declare)
[INFO] [stdout] 544 -                 .into(),
[INFO] [stdout] 543 +             <ts::TsEnumDeclaration as Into<_>>::into(self.ts_enum_declaration(span, id, body, is_const, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsModuleDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:557:13
[INFO] [stdout]     |
[INFO] [stdout] 557 | /             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 558 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 557 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 558 -                 .into(),
[INFO] [stdout] 557 +             self.ts_module_declaration(span, id, body, kind, declare),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 558 -                 .into(),
[INFO] [stdout] 557 +             <ts::TsModuleDeclaration as Into<_>>::into(self.ts_module_declaration(span, id, body, kind, declare)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsGlobalDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:569:35
[INFO] [stdout]     |
[INFO] [stdout] 569 |         Decl::TsGlobalDeclaration(self.ts_global_declaration(span, id, body, declare).into())
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 569 -         Decl::TsGlobalDeclaration(self.ts_global_declaration(span, id, body, declare).into())
[INFO] [stdout] 569 +         Decl::TsGlobalDeclaration(self.ts_global_declaration(span, id, body, declare))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 569 -         Decl::TsGlobalDeclaration(self.ts_global_declaration(span, id, body, declare).into())
[INFO] [stdout] 569 +         Decl::TsGlobalDeclaration(<ts::TsGlobalDeclaration as Into<_>>::into(self.ts_global_declaration(span, id, body, declare)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsImportEqualsDeclaration`
[INFO] [stdout]    --> src/generated/ast_builder.rs:580:13
[INFO] [stdout]     |
[INFO] [stdout] 580 | /             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 581 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 580 -             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 581 -                 .into(),
[INFO] [stdout] 580 +             self.ts_import_equals_declaration(span, id, module_reference, import_kind),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 580 -             self.ts_import_equals_declaration(span, id, module_reference, import_kind)
[INFO] [stdout] 581 -                 .into(),
[INFO] [stdout] 580 +             <ts::TsImportEqualsDeclaration as Into<_>>::into(self.ts_import_equals_declaration(span, id, module_reference, import_kind)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]    --> src/generated/ast_builder.rs:586:35
[INFO] [stdout]     |
[INFO] [stdout] 586 |         Expr::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 586 -         Expr::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 586 +         Expr::IdentifierReference(self.identifier_reference(span, name))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 586 -         Expr::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 586 +         Expr::IdentifierReference(<js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:590:30
[INFO] [stdout]     |
[INFO] [stdout] 590 |         Expr::ThisExpression(self.this_expression(span).into())
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 590 -         Expr::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 590 +         Expr::ThisExpression(self.this_expression(span))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 590 -         Expr::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 590 +         Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]    --> src/generated/ast_builder.rs:594:21
[INFO] [stdout]     |
[INFO] [stdout] 594 |         Expr::Super(self.super_(span).into())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 594 -         Expr::Super(self.super_(span).into())
[INFO] [stdout] 594 +         Expr::Super(self.super_(span))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 594 -         Expr::Super(self.super_(span).into())
[INFO] [stdout] 594 +         Expr::Super(<js::Super as Into<_>>::into(self.super_(span)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]    --> src/generated/ast_builder.rs:603:28
[INFO] [stdout]     |
[INFO] [stdout] 603 |         Expr::MetaProperty(self.meta_property(span, meta, property).into())
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 603 -         Expr::MetaProperty(self.meta_property(span, meta, property).into())
[INFO] [stdout] 603 +         Expr::MetaProperty(self.meta_property(span, meta, property))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 603 -         Expr::MetaProperty(self.meta_property(span, meta, property).into())
[INFO] [stdout] 603 +         Expr::MetaProperty(<js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:607:29
[INFO] [stdout]     |
[INFO] [stdout] 607 |         Expr::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 607 -         Expr::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 607 +         Expr::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 607 -         Expr::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 607 +         Expr::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:611:30
[INFO] [stdout]     |
[INFO] [stdout] 611 |         Expr::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 611 -         Expr::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout] 611 +         Expr::NumericLiteral(self.numeric_literal(span, value, raw))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 611 -         Expr::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout] 611 +         Expr::NumericLiteral(<js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:615:29
[INFO] [stdout]     |
[INFO] [stdout] 615 |         Expr::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 615 -         Expr::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout] 615 +         Expr::BigIntLiteral(self.big_int_literal(span, raw))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 615 -         Expr::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout] 615 +         Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:619:30
[INFO] [stdout]     |
[INFO] [stdout] 619 |         Expr::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 619 -         Expr::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout] 619 +         Expr::BooleanLiteral(self.boolean_literal(span, value))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 619 -         Expr::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout] 619 +         Expr::BooleanLiteral(<js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:623:27
[INFO] [stdout]     |
[INFO] [stdout] 623 |         Expr::NullLiteral(self.null_literal(span).into())
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 623 -         Expr::NullLiteral(self.null_literal(span).into())
[INFO] [stdout] 623 +         Expr::NullLiteral(self.null_literal(span))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 623 -         Expr::NullLiteral(self.null_literal(span).into())
[INFO] [stdout] 623 +         Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:627:29
[INFO] [stdout]     |
[INFO] [stdout] 627 |         Expr::RegExpLiteral(self.reg_exp_literal(span, pattern, flags).into())
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 627 -         Expr::RegExpLiteral(self.reg_exp_literal(span, pattern, flags).into())
[INFO] [stdout] 627 +         Expr::RegExpLiteral(self.reg_exp_literal(span, pattern, flags))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 627 -         Expr::RegExpLiteral(self.reg_exp_literal(span, pattern, flags).into())
[INFO] [stdout] 627 +         Expr::RegExpLiteral(<js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]    --> src/generated/ast_builder.rs:636:31
[INFO] [stdout]     |
[INFO] [stdout] 636 |         Expr::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 636 -         Expr::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 636 +         Expr::TemplateLiteral(self.template_literal(span, quasis, expressions))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 636 -         Expr::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 636 +         Expr::TemplateLiteral(<js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:646:32
[INFO] [stdout]     |
[INFO] [stdout] 646 |         Expr::BinaryExpression(self.binary_expression(span, left, right, operator).into())
[INFO] [stdout]     |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 646 -         Expr::BinaryExpression(self.binary_expression(span, left, right, operator).into())
[INFO] [stdout] 646 +         Expr::BinaryExpression(self.binary_expression(span, left, right, operator))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 646 -         Expr::BinaryExpression(self.binary_expression(span, left, right, operator).into())
[INFO] [stdout] 646 +         Expr::BinaryExpression(<js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:656:33
[INFO] [stdout]     |
[INFO] [stdout] 656 |         Expr::LogicalExpression(self.logical_expression(span, left, right, operator).into())
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 656 -         Expr::LogicalExpression(self.logical_expression(span, left, right, operator).into())
[INFO] [stdout] 656 +         Expr::LogicalExpression(self.logical_expression(span, left, right, operator))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 656 -         Expr::LogicalExpression(self.logical_expression(span, left, right, operator).into())
[INFO] [stdout] 656 +         Expr::LogicalExpression(<js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:665:31
[INFO] [stdout]     |
[INFO] [stdout] 665 |         Expr::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -         Expr::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout] 665 +         Expr::UnaryExpression(self.unary_expression(span, argument, operator))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -         Expr::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout] 665 +         Expr::UnaryExpression(<js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:676:13
[INFO] [stdout]     |
[INFO] [stdout] 676 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 677 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 676 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 677 -                 .into(),
[INFO] [stdout] 676 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 676 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 677 -                 .into(),
[INFO] [stdout] 676 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:689:13
[INFO] [stdout]     |
[INFO] [stdout] 689 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 690 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 689 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 690 -                 .into(),
[INFO] [stdout] 689 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 689 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 690 -                 .into(),
[INFO] [stdout] 689 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:702:13
[INFO] [stdout]     |
[INFO] [stdout] 702 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 703 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 702 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 703 -                 .into(),
[INFO] [stdout] 702 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 702 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 703 -                 .into(),
[INFO] [stdout] 702 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:708:34
[INFO] [stdout]     |
[INFO] [stdout] 708 |         Expr::SequenceExpression(self.sequence_expression(span, expressions).into())
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 708 -         Expr::SequenceExpression(self.sequence_expression(span, expressions).into())
[INFO] [stdout] 708 +         Expr::SequenceExpression(self.sequence_expression(span, expressions))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 708 -         Expr::SequenceExpression(self.sequence_expression(span, expressions).into())
[INFO] [stdout] 708 +         Expr::SequenceExpression(<js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:720:13
[INFO] [stdout]     |
[INFO] [stdout] 720 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 721 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 720 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 721 -                 .into(),
[INFO] [stdout] 720 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 720 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 721 -                 .into(),
[INFO] [stdout] 720 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:734:13
[INFO] [stdout]     |
[INFO] [stdout] 734 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 735 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 734 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 735 -                 .into(),
[INFO] [stdout] 734 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 734 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 735 -                 .into(),
[INFO] [stdout] 734 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:740:31
[INFO] [stdout]     |
[INFO] [stdout] 740 |         Expr::ChainExpression(self.chain_expression(span, expression).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 740 -         Expr::ChainExpression(self.chain_expression(span, expression).into())
[INFO] [stdout] 740 +         Expr::ChainExpression(self.chain_expression(span, expression))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 740 -         Expr::ChainExpression(self.chain_expression(span, expression).into())
[INFO] [stdout] 740 +         Expr::ChainExpression(<js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:751:13
[INFO] [stdout]     |
[INFO] [stdout] 751 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 752 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 751 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 752 -                 .into(),
[INFO] [stdout] 751 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 751 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 752 -                 .into(),
[INFO] [stdout] 751 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:764:13
[INFO] [stdout]     |
[INFO] [stdout] 764 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 765 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 764 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 765 -                 .into(),
[INFO] [stdout] 764 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 764 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 765 -                 .into(),
[INFO] [stdout] 764 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:780:13
[INFO] [stdout]     |
[INFO] [stdout] 780 | /             self.arrow_function_expression(
[INFO] [stdout] 781 | |                 span,
[INFO] [stdout] 782 | |                 expression,
[INFO] [stdout] 783 | |                 r#async,
[INFO] [stdout] ...   |
[INFO] [stdout] 789 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 788 -             )
[INFO] [stdout] 789 -             .into(),
[INFO] [stdout] 788 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 780 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 781 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 787 |                 body,
[INFO] [stdout] 788 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:798:31
[INFO] [stdout]     |
[INFO] [stdout] 798 |         Expr::ArrayExpression(self.array_expression(span, elements).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 798 -         Expr::ArrayExpression(self.array_expression(span, elements).into())
[INFO] [stdout] 798 +         Expr::ArrayExpression(self.array_expression(span, elements))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 798 -         Expr::ArrayExpression(self.array_expression(span, elements).into())
[INFO] [stdout] 798 +         Expr::ArrayExpression(<js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:806:32
[INFO] [stdout]     |
[INFO] [stdout] 806 |         Expr::ObjectExpression(self.object_expression(span, properties).into())
[INFO] [stdout]     |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 806 -         Expr::ObjectExpression(self.object_expression(span, properties).into())
[INFO] [stdout] 806 +         Expr::ObjectExpression(self.object_expression(span, properties))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 806 -         Expr::ObjectExpression(self.object_expression(span, properties).into())
[INFO] [stdout] 806 +         Expr::ObjectExpression(<js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:810:39
[INFO] [stdout]     |
[INFO] [stdout] 810 |         Expr::ParenthesizedExpression(self.parenthesized_expression(span, expression).into())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 810 -         Expr::ParenthesizedExpression(self.parenthesized_expression(span, expression).into())
[INFO] [stdout] 810 +         Expr::ParenthesizedExpression(self.parenthesized_expression(span, expression))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 810 -         Expr::ParenthesizedExpression(self.parenthesized_expression(span, expression).into())
[INFO] [stdout] 810 +         Expr::ParenthesizedExpression(<js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]    --> src/generated/ast_builder.rs:827:13
[INFO] [stdout]     |
[INFO] [stdout] 827 | /             self.function(
[INFO] [stdout] 828 | |                 span,
[INFO] [stdout] 829 | |                 function_type,
[INFO] [stdout] 830 | |                 id,
[INFO] [stdout] ...   |
[INFO] [stdout] 839 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 838 -             )
[INFO] [stdout] 839 -             .into(),
[INFO] [stdout] 838 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 827 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 828 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 837 |                 r#async,
[INFO] [stdout] 838 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]    --> src/generated/ast_builder.rs:858:13
[INFO] [stdout]     |
[INFO] [stdout] 858 | /             self.class(
[INFO] [stdout] 859 | |                 span,
[INFO] [stdout] 860 | |                 class_type,
[INFO] [stdout] 861 | |                 decorators,
[INFO] [stdout] ...   |
[INFO] [stdout] 871 | |             .into(),
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 870 -             )
[INFO] [stdout] 871 -             .into(),
[INFO] [stdout] 870 +             ),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 858 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 859 |                 span,
[INFO] [stdout] ...
[INFO] [stdout] 869 |                 declare,
[INFO] [stdout] 870 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:884:13
[INFO] [stdout]     |
[INFO] [stdout] 884 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 885 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 884 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 885 -                 .into(),
[INFO] [stdout] 884 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 885 -                 .into(),
[INFO] [stdout] 884 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:890:31
[INFO] [stdout]     |
[INFO] [stdout] 890 |         Expr::AwaitExpression(self.await_expression(span, argument).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 890 -         Expr::AwaitExpression(self.await_expression(span, argument).into())
[INFO] [stdout] 890 +         Expr::AwaitExpression(self.await_expression(span, argument))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 890 -         Expr::AwaitExpression(self.await_expression(span, argument).into())
[INFO] [stdout] 890 +         Expr::AwaitExpression(<js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:899:31
[INFO] [stdout]     |
[INFO] [stdout] 899 |         Expr::YieldExpression(self.yield_expression(span, argument, delegate).into())
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 899 -         Expr::YieldExpression(self.yield_expression(span, argument, delegate).into())
[INFO] [stdout] 899 +         Expr::YieldExpression(self.yield_expression(span, argument, delegate))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 899 -         Expr::YieldExpression(self.yield_expression(span, argument, delegate).into())
[INFO] [stdout] 899 +         Expr::YieldExpression(<js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]    --> src/generated/ast_builder.rs:903:33
[INFO] [stdout]     |
[INFO] [stdout] 903 |         Expr::PrivateIdentifier(self.private_identifier(span, name).into())
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 903 -         Expr::PrivateIdentifier(self.private_identifier(span, name).into())
[INFO] [stdout] 903 +         Expr::PrivateIdentifier(self.private_identifier(span, name))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 903 -         Expr::PrivateIdentifier(self.private_identifier(span, name).into())
[INFO] [stdout] 903 +         Expr::PrivateIdentifier(<js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:913:13
[INFO] [stdout]     |
[INFO] [stdout] 913 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 914 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 913 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 914 -                 .into(),
[INFO] [stdout] 913 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 913 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 914 -                 .into(),
[INFO] [stdout] 913 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:925:13
[INFO] [stdout]     |
[INFO] [stdout] 925 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 926 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 925 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 926 -                 .into(),
[INFO] [stdout] 925 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 925 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 926 -                 .into(),
[INFO] [stdout] 925 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]    --> src/generated/ast_builder.rs:937:13
[INFO] [stdout]     |
[INFO] [stdout] 937 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 938 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 937 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 938 -                 .into(),
[INFO] [stdout] 937 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 937 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 938 -                 .into(),
[INFO] [stdout] 937 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:943:35
[INFO] [stdout]     |
[INFO] [stdout] 943 |         Expr::TsNonNullExpression(self.ts_non_null_expression(span, expression).into())
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 943 -         Expr::TsNonNullExpression(self.ts_non_null_expression(span, expression).into())
[INFO] [stdout] 943 +         Expr::TsNonNullExpression(self.ts_non_null_expression(span, expression))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 943 -         Expr::TsNonNullExpression(self.ts_non_null_expression(span, expression).into())
[INFO] [stdout] 943 +         Expr::TsNonNullExpression(<ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]    --> src/generated/ast_builder.rs:953:13
[INFO] [stdout]     |
[INFO] [stdout] 953 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 954 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 953 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 954 -                 .into(),
[INFO] [stdout] 953 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 953 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 954 -                 .into(),
[INFO] [stdout] 953 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]    --> src/generated/ast_builder.rs:966:13
[INFO] [stdout]     |
[INFO] [stdout] 966 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 967 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 966 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 967 -                 .into(),
[INFO] [stdout] 966 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 966 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 967 -                 .into(),
[INFO] [stdout] 966 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]    --> src/generated/ast_builder.rs:979:13
[INFO] [stdout]     |
[INFO] [stdout] 979 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 980 | |                 .into(),
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 979 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 980 -                 .into(),
[INFO] [stdout] 979 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 979 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 980 -                 .into(),
[INFO] [stdout] 979 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BindingIdentifier`
[INFO] [stdout]    --> src/generated/ast_builder.rs:989:43
[INFO] [stdout]     |
[INFO] [stdout] 989 |         BindingPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 989 -         BindingPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 989 +         BindingPattern::BindingIdentifier(self.binding_identifier(span, name))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 989 -         BindingPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 989 +         BindingPattern::BindingIdentifier(<js::BindingIdentifier as Into<_>>::into(self.binding_identifier(span, name)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]    --> src/generated/ast_builder.rs:998:13
[INFO] [stdout]     |
[INFO] [stdout] 998 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 998 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 998 +             self.identifier_reference(span, name),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 998 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 998 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1011:13
[INFO] [stdout]      |
[INFO] [stdout] 1011 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1012 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1011 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1012 -                 .into(),
[INFO] [stdout] 1011 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1011 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1012 -                 .into(),
[INFO] [stdout] 1011 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1023:13
[INFO] [stdout]      |
[INFO] [stdout] 1023 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1024 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1023 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1024 -                 .into(),
[INFO] [stdout] 1023 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1023 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1024 -                 .into(),
[INFO] [stdout] 1023 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1035:13
[INFO] [stdout]      |
[INFO] [stdout] 1035 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1036 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1035 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1036 -                 .into(),
[INFO] [stdout] 1035 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1035 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1036 -                 .into(),
[INFO] [stdout] 1035 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1047:13
[INFO] [stdout]      |
[INFO] [stdout] 1047 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1048 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1047 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1048 -                 .into(),
[INFO] [stdout] 1047 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1047 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1048 -                 .into(),
[INFO] [stdout] 1047 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1058:13
[INFO] [stdout]      |
[INFO] [stdout] 1058 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1058 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1058 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1058 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1058 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1068:43
[INFO] [stdout]      |
[INFO] [stdout] 1068 |         BindingPattern::AssignmentPattern(self.assignment_pattern(span, left, right).into())
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         BindingPattern::AssignmentPattern(self.assignment_pattern(span, left, right).into())
[INFO] [stdout] 1068 +         BindingPattern::AssignmentPattern(self.assignment_pattern(span, left, right))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         BindingPattern::AssignmentPattern(self.assignment_pattern(span, left, right).into())
[INFO] [stdout] 1068 +         BindingPattern::AssignmentPattern(<js::AssignmentPattern as Into<_>>::into(self.assignment_pattern(span, left, right)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BindingRestElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1076:44
[INFO] [stdout]      |
[INFO] [stdout] 1076 |         BindingPattern::BindingRestElement(self.binding_rest_element(span, argument).into())
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1076 -         BindingPattern::BindingRestElement(self.binding_rest_element(span, argument).into())
[INFO] [stdout] 1076 +         BindingPattern::BindingRestElement(self.binding_rest_element(span, argument))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1076 -         BindingPattern::BindingRestElement(self.binding_rest_element(span, argument).into())
[INFO] [stdout] 1076 +         BindingPattern::BindingRestElement(<js::BindingRestElement as Into<_>>::into(self.binding_rest_element(span, argument)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1085:38
[INFO] [stdout]      |
[INFO] [stdout] 1085 |         BindingPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout]      |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1085 -         BindingPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 1085 +         BindingPattern::ArrayPattern(self.array_pattern(span, elements, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1085 -         BindingPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 1085 +         BindingPattern::ArrayPattern(<js::ArrayPattern as Into<_>>::into(self.array_pattern(span, elements, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1094:39
[INFO] [stdout]      |
[INFO] [stdout] 1094 |         BindingPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1094 -         BindingPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 1094 +         BindingPattern::ObjectPattern(self.object_pattern(span, properties, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1094 -         BindingPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 1094 +         BindingPattern::ObjectPattern(<js::ObjectPattern as Into<_>>::into(self.object_pattern(span, properties, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1103:13
[INFO] [stdout]      |
[INFO] [stdout] 1103 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1103 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1103 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1103 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1103 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1116:13
[INFO] [stdout]      |
[INFO] [stdout] 1116 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1117 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1117 -                 .into(),
[INFO] [stdout] 1116 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1117 -                 .into(),
[INFO] [stdout] 1116 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1128:13
[INFO] [stdout]      |
[INFO] [stdout] 1128 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1129 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1128 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1129 -                 .into(),
[INFO] [stdout] 1128 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1128 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1129 -                 .into(),
[INFO] [stdout] 1128 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1140:13
[INFO] [stdout]      |
[INFO] [stdout] 1140 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1141 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1140 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1141 -                 .into(),
[INFO] [stdout] 1140 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1140 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1141 -                 .into(),
[INFO] [stdout] 1140 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1152:13
[INFO] [stdout]      |
[INFO] [stdout] 1152 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1153 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1152 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1153 -                 .into(),
[INFO] [stdout] 1152 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1152 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1153 -                 .into(),
[INFO] [stdout] 1152 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1163:13
[INFO] [stdout]      |
[INFO] [stdout] 1163 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1163 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1163 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1163 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1163 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1173:49
[INFO] [stdout]      |
[INFO] [stdout] 1173 |         AssignmentTarget::ArrayAssignmentTarget(self.array_pattern(span, elements, rest).into())
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1173 -         AssignmentTarget::ArrayAssignmentTarget(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 1173 +         AssignmentTarget::ArrayAssignmentTarget(self.array_pattern(span, elements, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1173 -         AssignmentTarget::ArrayAssignmentTarget(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 1173 +         AssignmentTarget::ArrayAssignmentTarget(<js::ArrayPattern as Into<_>>::into(self.array_pattern(span, elements, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1182:50
[INFO] [stdout]      |
[INFO] [stdout] 1182 |         AssignmentTarget::ObjectAssignmentTarget(self.object_pattern(span, properties, rest).into())
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1182 -         AssignmentTarget::ObjectAssignmentTarget(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 1182 +         AssignmentTarget::ObjectAssignmentTarget(self.object_pattern(span, properties, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1182 -         AssignmentTarget::ObjectAssignmentTarget(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 1182 +         AssignmentTarget::ObjectAssignmentTarget(<js::ObjectPattern as Into<_>>::into(self.object_pattern(span, properties, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1190:53
[INFO] [stdout]      |
[INFO] [stdout] 1190 |         SimpleAssignmentTarget::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1190 -         SimpleAssignmentTarget::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 1190 +         SimpleAssignmentTarget::IdentifierReference(self.identifier_reference(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1190 -         SimpleAssignmentTarget::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 1190 +         SimpleAssignmentTarget::IdentifierReference(<js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1202:13
[INFO] [stdout]      |
[INFO] [stdout] 1202 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1203 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1202 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1203 -                 .into(),
[INFO] [stdout] 1202 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1202 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1203 -                 .into(),
[INFO] [stdout] 1202 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1214:13
[INFO] [stdout]      |
[INFO] [stdout] 1214 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1215 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1214 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1215 -                 .into(),
[INFO] [stdout] 1214 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1214 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1215 -                 .into(),
[INFO] [stdout] 1214 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1226:13
[INFO] [stdout]      |
[INFO] [stdout] 1226 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1227 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1226 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1227 -                 .into(),
[INFO] [stdout] 1226 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1226 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1227 -                 .into(),
[INFO] [stdout] 1226 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1238:13
[INFO] [stdout]      |
[INFO] [stdout] 1238 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1239 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1238 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1239 -                 .into(),
[INFO] [stdout] 1238 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1238 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1239 -                 .into(),
[INFO] [stdout] 1238 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1249:13
[INFO] [stdout]      |
[INFO] [stdout] 1249 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1249 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1249 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1249 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1249 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1254:37
[INFO] [stdout]      |
[INFO] [stdout] 1254 |         PropertyKey::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1254 -         PropertyKey::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 1254 +         PropertyKey::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1254 -         PropertyKey::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 1254 +         PropertyKey::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1263:13
[INFO] [stdout]      |
[INFO] [stdout] 1263 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1263 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1263 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1263 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1263 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1268:48
[INFO] [stdout]      |
[INFO] [stdout] 1268 |         PropertyKey::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1268 -         PropertyKey::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 1268 +         PropertyKey::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1268 -         PropertyKey::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 1268 +         PropertyKey::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1272:39
[INFO] [stdout]      |
[INFO] [stdout] 1272 |         PropertyKey::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1272 -         PropertyKey::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 1272 +         PropertyKey::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1272 -         PropertyKey::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 1272 +         PropertyKey::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1282:13
[INFO] [stdout]      |
[INFO] [stdout] 1282 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1282 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 1282 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1282 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 1282 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1293:13
[INFO] [stdout]      |
[INFO] [stdout] 1293 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1293 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 1293 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1293 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 1293 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1304:13
[INFO] [stdout]      |
[INFO] [stdout] 1304 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1304 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 1304 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1304 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 1304 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1309:47
[INFO] [stdout]      |
[INFO] [stdout] 1309 |         PropertyKey::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1309 -         PropertyKey::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 1309 +         PropertyKey::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1309 -         PropertyKey::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 1309 +         PropertyKey::Expr(Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1314:13
[INFO] [stdout]      |
[INFO] [stdout] 1314 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1314 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 1314 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1314 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 1314 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1319:45
[INFO] [stdout]      |
[INFO] [stdout] 1319 |         PropertyKey::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1319 -         PropertyKey::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 1319 +         PropertyKey::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1319 -         PropertyKey::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 1319 +         PropertyKey::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1329:13
[INFO] [stdout]      |
[INFO] [stdout] 1329 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1329 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 1329 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1329 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 1329 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1340:13
[INFO] [stdout]      |
[INFO] [stdout] 1340 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1340 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 1340 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1340 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 1340 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1352:13
[INFO] [stdout]      |
[INFO] [stdout] 1352 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 1352 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 1352 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1364:13
[INFO] [stdout]      |
[INFO] [stdout] 1364 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1364 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 1364 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1364 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 1364 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1375:13
[INFO] [stdout]      |
[INFO] [stdout] 1375 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1375 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 1375 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1375 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 1375 +             <js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1387:13
[INFO] [stdout]      |
[INFO] [stdout] 1387 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1388 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1387 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1388 -                 .into(),
[INFO] [stdout] 1387 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1387 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1388 -                 .into(),
[INFO] [stdout] 1387 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1400:13
[INFO] [stdout]      |
[INFO] [stdout] 1400 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1401 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1400 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1401 -                 .into(),
[INFO] [stdout] 1400 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1400 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1401 -                 .into(),
[INFO] [stdout] 1400 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1413:13
[INFO] [stdout]      |
[INFO] [stdout] 1413 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1414 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1413 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1414 -                 .into(),
[INFO] [stdout] 1413 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1413 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1414 -                 .into(),
[INFO] [stdout] 1413 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1424:13
[INFO] [stdout]      |
[INFO] [stdout] 1424 |             self.sequence_expression(span, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1424 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 1424 +             self.sequence_expression(span, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1424 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 1424 +             <js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1437:13
[INFO] [stdout]      |
[INFO] [stdout] 1437 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1438 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1437 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1438 -                 .into(),
[INFO] [stdout] 1437 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1437 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1438 -                 .into(),
[INFO] [stdout] 1437 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1451:13
[INFO] [stdout]      |
[INFO] [stdout] 1451 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1452 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1451 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1452 -                 .into(),
[INFO] [stdout] 1451 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1451 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1452 -                 .into(),
[INFO] [stdout] 1451 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1462:13
[INFO] [stdout]      |
[INFO] [stdout] 1462 |             self.chain_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1462 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 1462 +             self.chain_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1462 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 1462 +             <js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1474:13
[INFO] [stdout]      |
[INFO] [stdout] 1474 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1475 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1474 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1475 -                 .into(),
[INFO] [stdout] 1474 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1474 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1475 -                 .into(),
[INFO] [stdout] 1474 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1487:13
[INFO] [stdout]      |
[INFO] [stdout] 1487 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1488 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1487 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1488 -                 .into(),
[INFO] [stdout] 1487 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1487 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1488 -                 .into(),
[INFO] [stdout] 1487 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1503:13
[INFO] [stdout]      |
[INFO] [stdout] 1503 | /             self.arrow_function_expression(
[INFO] [stdout] 1504 | |                 span,
[INFO] [stdout] 1505 | |                 expression,
[INFO] [stdout] 1506 | |                 r#async,
[INFO] [stdout] ...    |
[INFO] [stdout] 1512 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1511 -             )
[INFO] [stdout] 1512 -             .into(),
[INFO] [stdout] 1511 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1503 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 1504 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 1510 |                 body,
[INFO] [stdout] 1511 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1522:13
[INFO] [stdout]      |
[INFO] [stdout] 1522 |             self.array_expression(span, elements).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1522 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 1522 +             self.array_expression(span, elements),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1522 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 1522 +             <js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1532:13
[INFO] [stdout]      |
[INFO] [stdout] 1532 |             self.object_expression(span, properties).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1532 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 1532 +             self.object_expression(span, properties),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1532 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 1532 +             <js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1542:13
[INFO] [stdout]      |
[INFO] [stdout] 1542 |             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1542 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 1542 +             self.parenthesized_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1542 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 1542 +             <js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1560:13
[INFO] [stdout]      |
[INFO] [stdout] 1560 | /             self.function(
[INFO] [stdout] 1561 | |                 span,
[INFO] [stdout] 1562 | |                 function_type,
[INFO] [stdout] 1563 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 1572 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1571 -             )
[INFO] [stdout] 1572 -             .into(),
[INFO] [stdout] 1571 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1560 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 1561 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 1570 |                 r#async,
[INFO] [stdout] 1571 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1591:13
[INFO] [stdout]      |
[INFO] [stdout] 1591 | /             self.class(
[INFO] [stdout] 1592 | |                 span,
[INFO] [stdout] 1593 | |                 class_type,
[INFO] [stdout] 1594 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 1604 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1603 -             )
[INFO] [stdout] 1604 -             .into(),
[INFO] [stdout] 1603 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1591 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 1592 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 1602 |                 declare,
[INFO] [stdout] 1603 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1617:13
[INFO] [stdout]      |
[INFO] [stdout] 1617 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 1618 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1617 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 1618 -                 .into(),
[INFO] [stdout] 1617 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1617 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 1618 -                 .into(),
[INFO] [stdout] 1617 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1628:13
[INFO] [stdout]      |
[INFO] [stdout] 1628 |             self.await_expression(span, argument).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1628 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 1628 +             self.await_expression(span, argument),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1628 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 1628 +             <js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1639:13
[INFO] [stdout]      |
[INFO] [stdout] 1639 |             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1639 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 1639 +             self.yield_expression(span, argument, delegate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1639 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 1639 +             <js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1649:13
[INFO] [stdout]      |
[INFO] [stdout] 1649 |             self.private_identifier(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1649 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 1649 +             self.private_identifier(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1649 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 1649 +             <js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1660:13
[INFO] [stdout]      |
[INFO] [stdout] 1660 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1661 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1660 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1661 -                 .into(),
[INFO] [stdout] 1660 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1660 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 1661 -                 .into(),
[INFO] [stdout] 1660 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1672:13
[INFO] [stdout]      |
[INFO] [stdout] 1672 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1673 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1672 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1673 -                 .into(),
[INFO] [stdout] 1672 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1672 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 1673 -                 .into(),
[INFO] [stdout] 1672 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1684:13
[INFO] [stdout]      |
[INFO] [stdout] 1684 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1685 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1684 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1685 -                 .into(),
[INFO] [stdout] 1684 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1684 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 1685 -                 .into(),
[INFO] [stdout] 1684 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1695:13
[INFO] [stdout]      |
[INFO] [stdout] 1695 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1695 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1695 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1695 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 1695 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1706:13
[INFO] [stdout]      |
[INFO] [stdout] 1706 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 1707 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1706 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 1707 -                 .into(),
[INFO] [stdout] 1706 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1706 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 1707 -                 .into(),
[INFO] [stdout] 1706 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1719:13
[INFO] [stdout]      |
[INFO] [stdout] 1719 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 1720 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1719 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 1720 -                 .into(),
[INFO] [stdout] 1719 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1719 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 1720 -                 .into(),
[INFO] [stdout] 1719 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1732:13
[INFO] [stdout]      |
[INFO] [stdout] 1732 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 1733 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1732 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 1733 -                 .into(),
[INFO] [stdout] 1732 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1732 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 1733 -                 .into(),
[INFO] [stdout] 1732 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1742:42
[INFO] [stdout]      |
[INFO] [stdout] 1742 |         ModuleExportName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1742 -         ModuleExportName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 1742 +         ModuleExportName::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1742 -         ModuleExportName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 1742 +         ModuleExportName::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1751:41
[INFO] [stdout]      |
[INFO] [stdout] 1751 |         ModuleExportName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1751 -         ModuleExportName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 1751 +         ModuleExportName::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1751 -         ModuleExportName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 1751 +         ModuleExportName::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1756:13
[INFO] [stdout]      |
[INFO] [stdout] 1756 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1756 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1756 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1756 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 1756 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1761:45
[INFO] [stdout]      |
[INFO] [stdout] 1761 |         Argument::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1761 -         Argument::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 1761 +         Argument::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1761 -         Argument::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 1761 +         Argument::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1765:36
[INFO] [stdout]      |
[INFO] [stdout] 1765 |         Argument::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1765 -         Argument::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 1765 +         Argument::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1765 -         Argument::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 1765 +         Argument::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1775:13
[INFO] [stdout]      |
[INFO] [stdout] 1775 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1775 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 1775 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1775 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 1775 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1786:13
[INFO] [stdout]      |
[INFO] [stdout] 1786 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1786 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 1786 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1786 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 1786 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1797:13
[INFO] [stdout]      |
[INFO] [stdout] 1797 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1797 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 1797 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1797 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 1797 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1802:44
[INFO] [stdout]      |
[INFO] [stdout] 1802 |         Argument::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1802 -         Argument::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 1802 +         Argument::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1802 -         Argument::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 1802 +         Argument::Expr(Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1807:13
[INFO] [stdout]      |
[INFO] [stdout] 1807 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1807 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 1807 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1807 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 1807 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1812:42
[INFO] [stdout]      |
[INFO] [stdout] 1812 |         Argument::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1812 -         Argument::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 1812 +         Argument::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1812 -         Argument::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 1812 +         Argument::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1822:13
[INFO] [stdout]      |
[INFO] [stdout] 1822 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1822 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 1822 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1822 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 1822 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1833:13
[INFO] [stdout]      |
[INFO] [stdout] 1833 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1833 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 1833 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1833 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 1833 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1845:13
[INFO] [stdout]      |
[INFO] [stdout] 1845 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1845 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 1845 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1845 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 1845 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1857:13
[INFO] [stdout]      |
[INFO] [stdout] 1857 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1857 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 1857 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1857 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 1857 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1868:13
[INFO] [stdout]      |
[INFO] [stdout] 1868 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1868 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 1868 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1868 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 1868 +             <js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1880:13
[INFO] [stdout]      |
[INFO] [stdout] 1880 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1881 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1880 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1881 -                 .into(),
[INFO] [stdout] 1880 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1880 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 1881 -                 .into(),
[INFO] [stdout] 1880 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1893:13
[INFO] [stdout]      |
[INFO] [stdout] 1893 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1894 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1893 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1894 -                 .into(),
[INFO] [stdout] 1893 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1893 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 1894 -                 .into(),
[INFO] [stdout] 1893 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1906:13
[INFO] [stdout]      |
[INFO] [stdout] 1906 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1907 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1906 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1907 -                 .into(),
[INFO] [stdout] 1906 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1906 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 1907 -                 .into(),
[INFO] [stdout] 1906 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1917:13
[INFO] [stdout]      |
[INFO] [stdout] 1917 |             self.sequence_expression(span, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1917 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 1917 +             self.sequence_expression(span, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1917 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 1917 +             <js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1930:13
[INFO] [stdout]      |
[INFO] [stdout] 1930 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1931 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1930 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1931 -                 .into(),
[INFO] [stdout] 1930 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1930 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 1931 -                 .into(),
[INFO] [stdout] 1930 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1944:13
[INFO] [stdout]      |
[INFO] [stdout] 1944 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1945 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1944 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1945 -                 .into(),
[INFO] [stdout] 1944 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1944 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 1945 -                 .into(),
[INFO] [stdout] 1944 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1951:13
[INFO] [stdout]      |
[INFO] [stdout] 1951 |             self.chain_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1951 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 1951 +             self.chain_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1951 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 1951 +             <js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1963:13
[INFO] [stdout]      |
[INFO] [stdout] 1963 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1964 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1963 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1964 -                 .into(),
[INFO] [stdout] 1963 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1963 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 1964 -                 .into(),
[INFO] [stdout] 1963 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1976:13
[INFO] [stdout]      |
[INFO] [stdout] 1976 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1977 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1976 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1977 -                 .into(),
[INFO] [stdout] 1976 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1976 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 1977 -                 .into(),
[INFO] [stdout] 1976 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:1992:13
[INFO] [stdout]      |
[INFO] [stdout] 1992 | /             self.arrow_function_expression(
[INFO] [stdout] 1993 | |                 span,
[INFO] [stdout] 1994 | |                 expression,
[INFO] [stdout] 1995 | |                 r#async,
[INFO] [stdout] ...    |
[INFO] [stdout] 2001 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2000 -             )
[INFO] [stdout] 2001 -             .into(),
[INFO] [stdout] 2000 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1992 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 1993 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 1999 |                 body,
[INFO] [stdout] 2000 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2011:13
[INFO] [stdout]      |
[INFO] [stdout] 2011 |             self.array_expression(span, elements).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2011 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 2011 +             self.array_expression(span, elements),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2011 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 2011 +             <js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2021:13
[INFO] [stdout]      |
[INFO] [stdout] 2021 |             self.object_expression(span, properties).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2021 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 2021 +             self.object_expression(span, properties),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2021 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 2021 +             <js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2031:13
[INFO] [stdout]      |
[INFO] [stdout] 2031 |             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2031 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 2031 +             self.parenthesized_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2031 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 2031 +             <js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2049:13
[INFO] [stdout]      |
[INFO] [stdout] 2049 | /             self.function(
[INFO] [stdout] 2050 | |                 span,
[INFO] [stdout] 2051 | |                 function_type,
[INFO] [stdout] 2052 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 2061 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2060 -             )
[INFO] [stdout] 2061 -             .into(),
[INFO] [stdout] 2060 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2049 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 2050 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 2059 |                 r#async,
[INFO] [stdout] 2060 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2080:13
[INFO] [stdout]      |
[INFO] [stdout] 2080 | /             self.class(
[INFO] [stdout] 2081 | |                 span,
[INFO] [stdout] 2082 | |                 class_type,
[INFO] [stdout] 2083 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 2093 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2092 -             )
[INFO] [stdout] 2093 -             .into(),
[INFO] [stdout] 2092 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2080 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 2081 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 2091 |                 declare,
[INFO] [stdout] 2092 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2106:13
[INFO] [stdout]      |
[INFO] [stdout] 2106 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2107 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2106 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2107 -                 .into(),
[INFO] [stdout] 2106 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2106 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2107 -                 .into(),
[INFO] [stdout] 2106 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2113:13
[INFO] [stdout]      |
[INFO] [stdout] 2113 |             self.await_expression(span, argument).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2113 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 2113 +             self.await_expression(span, argument),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2113 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 2113 +             <js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2124:13
[INFO] [stdout]      |
[INFO] [stdout] 2124 |             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2124 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 2124 +             self.yield_expression(span, argument, delegate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2124 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 2124 +             <js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2130:13
[INFO] [stdout]      |
[INFO] [stdout] 2130 |             self.private_identifier(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2130 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 2130 +             self.private_identifier(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2130 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 2130 +             <js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2141:13
[INFO] [stdout]      |
[INFO] [stdout] 2141 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2142 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2141 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2142 -                 .into(),
[INFO] [stdout] 2141 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2141 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2142 -                 .into(),
[INFO] [stdout] 2141 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2153:13
[INFO] [stdout]      |
[INFO] [stdout] 2153 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2154 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2153 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2154 -                 .into(),
[INFO] [stdout] 2153 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2153 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2154 -                 .into(),
[INFO] [stdout] 2153 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2165:13
[INFO] [stdout]      |
[INFO] [stdout] 2165 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2166 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2165 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2166 -                 .into(),
[INFO] [stdout] 2165 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2165 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2166 -                 .into(),
[INFO] [stdout] 2165 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2176:13
[INFO] [stdout]      |
[INFO] [stdout] 2176 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2176 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2176 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2176 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2176 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2187:13
[INFO] [stdout]      |
[INFO] [stdout] 2187 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2188 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2187 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2188 -                 .into(),
[INFO] [stdout] 2187 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2187 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2188 -                 .into(),
[INFO] [stdout] 2187 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2200:13
[INFO] [stdout]      |
[INFO] [stdout] 2200 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2201 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2200 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2201 -                 .into(),
[INFO] [stdout] 2200 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2200 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2201 -                 .into(),
[INFO] [stdout] 2200 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2213:13
[INFO] [stdout]      |
[INFO] [stdout] 2213 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2214 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2213 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2214 -                 .into(),
[INFO] [stdout] 2213 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2213 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2214 -                 .into(),
[INFO] [stdout] 2213 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SpreadElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2219:33
[INFO] [stdout]      |
[INFO] [stdout] 2219 |         Argument::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2219 -         Argument::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout] 2219 +         Argument::SpreadElement(self.spread_element(span, argument))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2219 -         Argument::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout] 2219 +         Argument::SpreadElement(<js::SpreadElement as Into<_>>::into(self.spread_element(span, argument)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2233:13
[INFO] [stdout]      |
[INFO] [stdout] 2233 | /             self.object_property(span, key, value, kind, method, shorthand, computed)
[INFO] [stdout] 2234 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2233 -             self.object_property(span, key, value, kind, method, shorthand, computed)
[INFO] [stdout] 2234 -                 .into(),
[INFO] [stdout] 2233 +             self.object_property(span, key, value, kind, method, shorthand, computed),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2233 -             self.object_property(span, key, value, kind, method, shorthand, computed)
[INFO] [stdout] 2234 -                 .into(),
[INFO] [stdout] 2233 +             <js::ObjectProperty as Into<_>>::into(self.object_property(span, key, value, kind, method, shorthand, computed)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SpreadElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2243:43
[INFO] [stdout]      |
[INFO] [stdout] 2243 |         ObjectPropertyKind::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2243 -         ObjectPropertyKind::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout] 2243 +         ObjectPropertyKind::SpreadElement(self.spread_element(span, argument))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2243 -         ObjectPropertyKind::SpreadElement(self.spread_element(span, argument).into())
[INFO] [stdout] 2243 +         ObjectPropertyKind::SpreadElement(<js::SpreadElement as Into<_>>::into(self.spread_element(span, argument)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::VariableDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2254:13
[INFO] [stdout]      |
[INFO] [stdout] 2254 | /             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2255 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2254 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2255 -                 .into(),
[INFO] [stdout] 2254 +             self.variable_declaration(span, kind, declarators, declare),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2254 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2255 -                 .into(),
[INFO] [stdout] 2254 +             <js::VariableDeclaration as Into<_>>::into(self.variable_declaration(span, kind, declarators, declare)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2265:13
[INFO] [stdout]      |
[INFO] [stdout] 2265 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2265 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 2265 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2265 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 2265 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2270:53
[INFO] [stdout]      |
[INFO] [stdout] 2270 |         ForStatementInit::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2270 -         ForStatementInit::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 2270 +         ForStatementInit::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2270 -         ForStatementInit::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 2270 +         ForStatementInit::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2274:44
[INFO] [stdout]      |
[INFO] [stdout] 2274 |         ForStatementInit::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2274 -         ForStatementInit::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 2274 +         ForStatementInit::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2274 -         ForStatementInit::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 2274 +         ForStatementInit::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2284:13
[INFO] [stdout]      |
[INFO] [stdout] 2284 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2284 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 2284 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2284 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 2284 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2295:13
[INFO] [stdout]      |
[INFO] [stdout] 2295 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2295 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 2295 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2295 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 2295 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2306:13
[INFO] [stdout]      |
[INFO] [stdout] 2306 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2306 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 2306 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2306 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 2306 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2315:52
[INFO] [stdout]      |
[INFO] [stdout] 2315 |         ForStatementInit::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2315 -         ForStatementInit::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 2315 +         ForStatementInit::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2315 -         ForStatementInit::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 2315 +         ForStatementInit::Expr(Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2324:13
[INFO] [stdout]      |
[INFO] [stdout] 2324 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2324 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 2324 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2324 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 2324 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2329:50
[INFO] [stdout]      |
[INFO] [stdout] 2329 |         ForStatementInit::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2329 -         ForStatementInit::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 2329 +         ForStatementInit::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2329 -         ForStatementInit::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 2329 +         ForStatementInit::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2339:13
[INFO] [stdout]      |
[INFO] [stdout] 2339 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2339 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 2339 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2339 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 2339 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2350:13
[INFO] [stdout]      |
[INFO] [stdout] 2350 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2350 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 2350 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2350 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 2350 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2362:13
[INFO] [stdout]      |
[INFO] [stdout] 2362 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2362 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 2362 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2362 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 2362 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2374:13
[INFO] [stdout]      |
[INFO] [stdout] 2374 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2374 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 2374 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2374 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 2374 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2385:13
[INFO] [stdout]      |
[INFO] [stdout] 2385 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2385 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 2385 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2385 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 2385 +             <js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2397:13
[INFO] [stdout]      |
[INFO] [stdout] 2397 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 2398 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2397 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 2398 -                 .into(),
[INFO] [stdout] 2397 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2397 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 2398 -                 .into(),
[INFO] [stdout] 2397 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2410:13
[INFO] [stdout]      |
[INFO] [stdout] 2410 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 2411 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2410 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 2411 -                 .into(),
[INFO] [stdout] 2410 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2410 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 2411 -                 .into(),
[INFO] [stdout] 2410 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2423:13
[INFO] [stdout]      |
[INFO] [stdout] 2423 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 2424 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2423 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 2424 -                 .into(),
[INFO] [stdout] 2423 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2423 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 2424 -                 .into(),
[INFO] [stdout] 2423 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2434:13
[INFO] [stdout]      |
[INFO] [stdout] 2434 |             self.sequence_expression(span, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2434 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 2434 +             self.sequence_expression(span, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2434 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 2434 +             <js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2447:13
[INFO] [stdout]      |
[INFO] [stdout] 2447 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2448 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2447 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2448 -                 .into(),
[INFO] [stdout] 2447 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2447 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2448 -                 .into(),
[INFO] [stdout] 2447 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2461:13
[INFO] [stdout]      |
[INFO] [stdout] 2461 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 2462 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2461 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 2462 -                 .into(),
[INFO] [stdout] 2461 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2461 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 2462 -                 .into(),
[INFO] [stdout] 2461 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2472:13
[INFO] [stdout]      |
[INFO] [stdout] 2472 |             self.chain_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2472 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 2472 +             self.chain_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2472 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 2472 +             <js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2484:13
[INFO] [stdout]      |
[INFO] [stdout] 2484 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 2485 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2484 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 2485 -                 .into(),
[INFO] [stdout] 2484 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2484 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 2485 -                 .into(),
[INFO] [stdout] 2484 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2497:13
[INFO] [stdout]      |
[INFO] [stdout] 2497 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 2498 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2497 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 2498 -                 .into(),
[INFO] [stdout] 2497 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2497 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 2498 -                 .into(),
[INFO] [stdout] 2497 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2513:13
[INFO] [stdout]      |
[INFO] [stdout] 2513 | /             self.arrow_function_expression(
[INFO] [stdout] 2514 | |                 span,
[INFO] [stdout] 2515 | |                 expression,
[INFO] [stdout] 2516 | |                 r#async,
[INFO] [stdout] ...    |
[INFO] [stdout] 2522 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2521 -             )
[INFO] [stdout] 2522 -             .into(),
[INFO] [stdout] 2521 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2513 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 2514 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 2520 |                 body,
[INFO] [stdout] 2521 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2532:13
[INFO] [stdout]      |
[INFO] [stdout] 2532 |             self.array_expression(span, elements).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2532 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 2532 +             self.array_expression(span, elements),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2532 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 2532 +             <js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2542:13
[INFO] [stdout]      |
[INFO] [stdout] 2542 |             self.object_expression(span, properties).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2542 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 2542 +             self.object_expression(span, properties),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2542 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 2542 +             <js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2552:13
[INFO] [stdout]      |
[INFO] [stdout] 2552 |             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2552 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 2552 +             self.parenthesized_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2552 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 2552 +             <js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2570:13
[INFO] [stdout]      |
[INFO] [stdout] 2570 | /             self.function(
[INFO] [stdout] 2571 | |                 span,
[INFO] [stdout] 2572 | |                 function_type,
[INFO] [stdout] 2573 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 2582 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2581 -             )
[INFO] [stdout] 2582 -             .into(),
[INFO] [stdout] 2581 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2570 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 2571 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 2580 |                 r#async,
[INFO] [stdout] 2581 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2601:13
[INFO] [stdout]      |
[INFO] [stdout] 2601 | /             self.class(
[INFO] [stdout] 2602 | |                 span,
[INFO] [stdout] 2603 | |                 class_type,
[INFO] [stdout] 2604 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 2614 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2613 -             )
[INFO] [stdout] 2614 -             .into(),
[INFO] [stdout] 2613 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2601 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 2602 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 2612 |                 declare,
[INFO] [stdout] 2613 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2627:13
[INFO] [stdout]      |
[INFO] [stdout] 2627 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2628 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2627 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2628 -                 .into(),
[INFO] [stdout] 2627 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2627 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 2628 -                 .into(),
[INFO] [stdout] 2627 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2638:13
[INFO] [stdout]      |
[INFO] [stdout] 2638 |             self.await_expression(span, argument).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2638 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 2638 +             self.await_expression(span, argument),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2638 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 2638 +             <js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2649:13
[INFO] [stdout]      |
[INFO] [stdout] 2649 |             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2649 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 2649 +             self.yield_expression(span, argument, delegate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2649 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 2649 +             <js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2659:13
[INFO] [stdout]      |
[INFO] [stdout] 2659 |             self.private_identifier(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2659 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 2659 +             self.private_identifier(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2659 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 2659 +             <js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2670:13
[INFO] [stdout]      |
[INFO] [stdout] 2670 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2671 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2670 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2671 -                 .into(),
[INFO] [stdout] 2670 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2670 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2671 -                 .into(),
[INFO] [stdout] 2670 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2682:13
[INFO] [stdout]      |
[INFO] [stdout] 2682 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2683 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2682 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2683 -                 .into(),
[INFO] [stdout] 2682 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2682 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2683 -                 .into(),
[INFO] [stdout] 2682 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2694:13
[INFO] [stdout]      |
[INFO] [stdout] 2694 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2695 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2694 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2695 -                 .into(),
[INFO] [stdout] 2694 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2694 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2695 -                 .into(),
[INFO] [stdout] 2694 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2705:13
[INFO] [stdout]      |
[INFO] [stdout] 2705 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2705 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2705 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2705 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2705 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2716:13
[INFO] [stdout]      |
[INFO] [stdout] 2716 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2717 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2716 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2717 -                 .into(),
[INFO] [stdout] 2716 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2716 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 2717 -                 .into(),
[INFO] [stdout] 2716 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2729:13
[INFO] [stdout]      |
[INFO] [stdout] 2729 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2730 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2729 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2730 -                 .into(),
[INFO] [stdout] 2729 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2729 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 2730 -                 .into(),
[INFO] [stdout] 2729 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2742:13
[INFO] [stdout]      |
[INFO] [stdout] 2742 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2743 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2742 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2743 -                 .into(),
[INFO] [stdout] 2742 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2742 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 2743 -                 .into(),
[INFO] [stdout] 2742 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::VariableDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2755:13
[INFO] [stdout]      |
[INFO] [stdout] 2755 | /             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2756 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2755 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2756 -                 .into(),
[INFO] [stdout] 2755 +             self.variable_declaration(span, kind, declarators, declare),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2755 -             self.variable_declaration(span, kind, declarators, declare)
[INFO] [stdout] 2756 -                 .into(),
[INFO] [stdout] 2755 +             <js::VariableDeclaration as Into<_>>::into(self.variable_declaration(span, kind, declarators, declare)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2767:17
[INFO] [stdout]      |
[INFO] [stdout] 2767 |                 self.identifier_reference(span, name).into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2767 -                 self.identifier_reference(span, name).into(),
[INFO] [stdout] 2767 +                 self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2767 -                 self.identifier_reference(span, name).into(),
[INFO] [stdout] 2767 +                 <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2782:17
[INFO] [stdout]      |
[INFO] [stdout] 2782 | /                 self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2783 | |                     .into(),
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2782 -                 self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2783 -                     .into(),
[INFO] [stdout] 2782 +                 self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2782 -                 self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 2783 -                     .into(),
[INFO] [stdout] 2782 +                 <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2796:17
[INFO] [stdout]      |
[INFO] [stdout] 2796 | /                 self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2797 | |                     .into(),
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2796 -                 self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2797 -                     .into(),
[INFO] [stdout] 2796 +                 self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2796 -                 self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 2797 -                     .into(),
[INFO] [stdout] 2796 +                 <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2810:17
[INFO] [stdout]      |
[INFO] [stdout] 2810 | /                 self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2811 | |                     .into(),
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2810 -                 self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2811 -                     .into(),
[INFO] [stdout] 2810 +                 self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2810 -                 self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 2811 -                     .into(),
[INFO] [stdout] 2810 +                 <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2824:17
[INFO] [stdout]      |
[INFO] [stdout] 2824 | /                 self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2825 | |                     .into(),
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2824 -                 self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2825 -                     .into(),
[INFO] [stdout] 2824 +                 self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2824 -                 self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 2825 -                     .into(),
[INFO] [stdout] 2824 +                 <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2837:17
[INFO] [stdout]      |
[INFO] [stdout] 2837 |                 self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2837 -                 self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2837 +                 self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2837 -                 self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 2837 +                 <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2849:13
[INFO] [stdout]      |
[INFO] [stdout] 2849 |             self.array_pattern(span, elements, rest).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2849 -             self.array_pattern(span, elements, rest).into(),
[INFO] [stdout] 2849 +             self.array_pattern(span, elements, rest),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2849 -             self.array_pattern(span, elements, rest).into(),
[INFO] [stdout] 2849 +             <js::ArrayPattern as Into<_>>::into(self.array_pattern(span, elements, rest)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2860:13
[INFO] [stdout]      |
[INFO] [stdout] 2860 |             self.object_pattern(span, properties, rest).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2860 -             self.object_pattern(span, properties, rest).into(),
[INFO] [stdout] 2860 +             self.object_pattern(span, properties, rest),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2860 -             self.object_pattern(span, properties, rest).into(),
[INFO] [stdout] 2860 +             <js::ObjectPattern as Into<_>>::into(self.object_pattern(span, properties, rest)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::FunctionBody`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2870:41
[INFO] [stdout]      |
[INFO] [stdout] 2870 |         ArrowFunctionBody::FunctionBody(self.function_body(span, directives, body).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2870 -         ArrowFunctionBody::FunctionBody(self.function_body(span, directives, body).into())
[INFO] [stdout] 2870 +         ArrowFunctionBody::FunctionBody(self.function_body(span, directives, body))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2870 -         ArrowFunctionBody::FunctionBody(self.function_body(span, directives, body).into())
[INFO] [stdout] 2870 +         ArrowFunctionBody::FunctionBody(<js::FunctionBody as Into<_>>::into(self.function_body(span, directives, body)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2879:13
[INFO] [stdout]      |
[INFO] [stdout] 2879 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2879 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 2879 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2879 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 2879 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2884:54
[INFO] [stdout]      |
[INFO] [stdout] 2884 |         ArrowFunctionBody::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2884 -         ArrowFunctionBody::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 2884 +         ArrowFunctionBody::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2884 -         ArrowFunctionBody::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 2884 +         ArrowFunctionBody::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2888:45
[INFO] [stdout]      |
[INFO] [stdout] 2888 |         ArrowFunctionBody::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         ArrowFunctionBody::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 2888 +         ArrowFunctionBody::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         ArrowFunctionBody::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 2888 +         ArrowFunctionBody::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2898:13
[INFO] [stdout]      |
[INFO] [stdout] 2898 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2898 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 2898 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2898 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 2898 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2909:13
[INFO] [stdout]      |
[INFO] [stdout] 2909 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2909 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 2909 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2909 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 2909 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2920:13
[INFO] [stdout]      |
[INFO] [stdout] 2920 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2920 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 2920 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2920 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 2920 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2929:53
[INFO] [stdout]      |
[INFO] [stdout] 2929 |         ArrowFunctionBody::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2929 -         ArrowFunctionBody::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 2929 +         ArrowFunctionBody::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2929 -         ArrowFunctionBody::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 2929 +         ArrowFunctionBody::Expr(Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2938:13
[INFO] [stdout]      |
[INFO] [stdout] 2938 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2938 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 2938 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2938 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 2938 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2943:51
[INFO] [stdout]      |
[INFO] [stdout] 2943 |         ArrowFunctionBody::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2943 -         ArrowFunctionBody::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 2943 +         ArrowFunctionBody::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2943 -         ArrowFunctionBody::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 2943 +         ArrowFunctionBody::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2953:13
[INFO] [stdout]      |
[INFO] [stdout] 2953 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2953 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 2953 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2953 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 2953 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2964:13
[INFO] [stdout]      |
[INFO] [stdout] 2964 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2964 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 2964 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2964 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 2964 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2976:13
[INFO] [stdout]      |
[INFO] [stdout] 2976 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2976 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 2976 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2976 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 2976 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2988:13
[INFO] [stdout]      |
[INFO] [stdout] 2988 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 2988 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 2988 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:2999:13
[INFO] [stdout]      |
[INFO] [stdout] 2999 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2999 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 2999 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2999 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 2999 +             <js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3011:13
[INFO] [stdout]      |
[INFO] [stdout] 3011 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3012 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3011 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3012 -                 .into(),
[INFO] [stdout] 3011 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3011 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3012 -                 .into(),
[INFO] [stdout] 3011 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3024:13
[INFO] [stdout]      |
[INFO] [stdout] 3024 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3025 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3024 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3025 -                 .into(),
[INFO] [stdout] 3024 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3024 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3025 -                 .into(),
[INFO] [stdout] 3024 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3037:13
[INFO] [stdout]      |
[INFO] [stdout] 3037 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3038 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3037 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3038 -                 .into(),
[INFO] [stdout] 3037 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3037 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3038 -                 .into(),
[INFO] [stdout] 3037 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3048:13
[INFO] [stdout]      |
[INFO] [stdout] 3048 |             self.sequence_expression(span, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3048 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 3048 +             self.sequence_expression(span, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3048 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 3048 +             <js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3061:13
[INFO] [stdout]      |
[INFO] [stdout] 3061 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3062 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3061 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3062 -                 .into(),
[INFO] [stdout] 3061 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3061 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3062 -                 .into(),
[INFO] [stdout] 3061 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3075:13
[INFO] [stdout]      |
[INFO] [stdout] 3075 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3076 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3075 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3076 -                 .into(),
[INFO] [stdout] 3075 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3076 -                 .into(),
[INFO] [stdout] 3075 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3086:13
[INFO] [stdout]      |
[INFO] [stdout] 3086 |             self.chain_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3086 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 3086 +             self.chain_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3086 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 3086 +             <js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3098:13
[INFO] [stdout]      |
[INFO] [stdout] 3098 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3099 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3098 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3099 -                 .into(),
[INFO] [stdout] 3098 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3098 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3099 -                 .into(),
[INFO] [stdout] 3098 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3111:13
[INFO] [stdout]      |
[INFO] [stdout] 3111 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3112 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3111 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3112 -                 .into(),
[INFO] [stdout] 3111 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3111 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3112 -                 .into(),
[INFO] [stdout] 3111 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3127:13
[INFO] [stdout]      |
[INFO] [stdout] 3127 | /             self.arrow_function_expression(
[INFO] [stdout] 3128 | |                 span,
[INFO] [stdout] 3129 | |                 expression,
[INFO] [stdout] 3130 | |                 r#async,
[INFO] [stdout] ...    |
[INFO] [stdout] 3136 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3135 -             )
[INFO] [stdout] 3136 -             .into(),
[INFO] [stdout] 3135 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3127 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 3128 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3134 |                 body,
[INFO] [stdout] 3135 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3146:13
[INFO] [stdout]      |
[INFO] [stdout] 3146 |             self.array_expression(span, elements).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3146 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 3146 +             self.array_expression(span, elements),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3146 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 3146 +             <js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3156:13
[INFO] [stdout]      |
[INFO] [stdout] 3156 |             self.object_expression(span, properties).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3156 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 3156 +             self.object_expression(span, properties),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3156 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 3156 +             <js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3166:13
[INFO] [stdout]      |
[INFO] [stdout] 3166 |             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3166 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 3166 +             self.parenthesized_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3166 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 3166 +             <js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3184:13
[INFO] [stdout]      |
[INFO] [stdout] 3184 | /             self.function(
[INFO] [stdout] 3185 | |                 span,
[INFO] [stdout] 3186 | |                 function_type,
[INFO] [stdout] 3187 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 3196 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3195 -             )
[INFO] [stdout] 3196 -             .into(),
[INFO] [stdout] 3195 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3184 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 3185 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3194 |                 r#async,
[INFO] [stdout] 3195 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3215:13
[INFO] [stdout]      |
[INFO] [stdout] 3215 | /             self.class(
[INFO] [stdout] 3216 | |                 span,
[INFO] [stdout] 3217 | |                 class_type,
[INFO] [stdout] 3218 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 3228 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3227 -             )
[INFO] [stdout] 3228 -             .into(),
[INFO] [stdout] 3227 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3215 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 3216 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3226 |                 declare,
[INFO] [stdout] 3227 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3241:13
[INFO] [stdout]      |
[INFO] [stdout] 3241 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3242 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3241 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3242 -                 .into(),
[INFO] [stdout] 3241 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3241 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3242 -                 .into(),
[INFO] [stdout] 3241 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3252:13
[INFO] [stdout]      |
[INFO] [stdout] 3252 |             self.await_expression(span, argument).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3252 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 3252 +             self.await_expression(span, argument),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3252 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 3252 +             <js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3263:13
[INFO] [stdout]      |
[INFO] [stdout] 3263 |             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3263 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 3263 +             self.yield_expression(span, argument, delegate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3263 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 3263 +             <js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3273:13
[INFO] [stdout]      |
[INFO] [stdout] 3273 |             self.private_identifier(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3273 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 3273 +             self.private_identifier(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3273 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 3273 +             <js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3284:13
[INFO] [stdout]      |
[INFO] [stdout] 3284 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 3285 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3284 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 3285 -                 .into(),
[INFO] [stdout] 3284 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3284 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 3285 -                 .into(),
[INFO] [stdout] 3284 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3296:13
[INFO] [stdout]      |
[INFO] [stdout] 3296 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 3297 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3296 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 3297 -                 .into(),
[INFO] [stdout] 3296 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3296 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 3297 -                 .into(),
[INFO] [stdout] 3296 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3308:13
[INFO] [stdout]      |
[INFO] [stdout] 3308 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 3309 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3308 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 3309 -                 .into(),
[INFO] [stdout] 3308 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3308 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 3309 -                 .into(),
[INFO] [stdout] 3308 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3319:13
[INFO] [stdout]      |
[INFO] [stdout] 3319 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3319 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 3319 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3319 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 3319 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3330:13
[INFO] [stdout]      |
[INFO] [stdout] 3330 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 3331 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3330 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 3331 -                 .into(),
[INFO] [stdout] 3330 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3330 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 3331 -                 .into(),
[INFO] [stdout] 3330 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3343:13
[INFO] [stdout]      |
[INFO] [stdout] 3343 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 3344 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3343 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 3344 -                 .into(),
[INFO] [stdout] 3343 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3343 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 3344 -                 .into(),
[INFO] [stdout] 3343 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3356:13
[INFO] [stdout]      |
[INFO] [stdout] 3356 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 3357 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 3357 -                 .into(),
[INFO] [stdout] 3356 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 3357 -                 .into(),
[INFO] [stdout] 3356 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::FormalParameter`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3371:13
[INFO] [stdout]      |
[INFO] [stdout] 3371 | /             self.formal_parameter(
[INFO] [stdout] 3372 | |                 span,
[INFO] [stdout] 3373 | |                 decorators,
[INFO] [stdout] 3374 | |                 pattern,
[INFO] [stdout] ...    |
[INFO] [stdout] 3379 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3378 -             )
[INFO] [stdout] 3379 -             .into(),
[INFO] [stdout] 3378 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3371 ~             <js::FormalParameter as Into<_>>::into(self.formal_parameter(
[INFO] [stdout] 3372 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3377 |                 optional,
[INFO] [stdout] 3378 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsParameterProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3393:13
[INFO] [stdout]      |
[INFO] [stdout] 3393 | /             self.ts_parameter_property(
[INFO] [stdout] 3394 | |                 span,
[INFO] [stdout] 3395 | |                 decorators,
[INFO] [stdout] 3396 | |                 parameter,
[INFO] [stdout] ...    |
[INFO] [stdout] 3401 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3400 -             )
[INFO] [stdout] 3401 -             .into(),
[INFO] [stdout] 3400 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3393 ~             <ts::TsParameterProperty as Into<_>>::into(self.ts_parameter_property(
[INFO] [stdout] 3394 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3399 |                 accessibility,
[INFO] [stdout] 3400 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BindingIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3410:51
[INFO] [stdout]      |
[INFO] [stdout] 3410 |         FormalParameterPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3410 -         FormalParameterPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 3410 +         FormalParameterPattern::BindingIdentifier(self.binding_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3410 -         FormalParameterPattern::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 3410 +         FormalParameterPattern::BindingIdentifier(<js::BindingIdentifier as Into<_>>::into(self.binding_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3419:46
[INFO] [stdout]      |
[INFO] [stdout] 3419 |         FormalParameterPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3419 -         FormalParameterPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 3419 +         FormalParameterPattern::ArrayPattern(self.array_pattern(span, elements, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3419 -         FormalParameterPattern::ArrayPattern(self.array_pattern(span, elements, rest).into())
[INFO] [stdout] 3419 +         FormalParameterPattern::ArrayPattern(<js::ArrayPattern as Into<_>>::into(self.array_pattern(span, elements, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectPattern`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3428:47
[INFO] [stdout]      |
[INFO] [stdout] 3428 |         FormalParameterPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3428 -         FormalParameterPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 3428 +         FormalParameterPattern::ObjectPattern(self.object_pattern(span, properties, rest))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3428 -         FormalParameterPattern::ObjectPattern(self.object_pattern(span, properties, rest).into())
[INFO] [stdout] 3428 +         FormalParameterPattern::ObjectPattern(<js::ObjectPattern as Into<_>>::into(self.object_pattern(span, properties, rest)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MethodDefinition`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3446:13
[INFO] [stdout]      |
[INFO] [stdout] 3446 | /             self.method_definition(
[INFO] [stdout] 3447 | |                 span,
[INFO] [stdout] 3448 | |                 decorators,
[INFO] [stdout] 3449 | |                 key,
[INFO] [stdout] ...    |
[INFO] [stdout] 3459 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3458 -             )
[INFO] [stdout] 3459 -             .into(),
[INFO] [stdout] 3458 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3446 ~             <js::MethodDefinition as Into<_>>::into(self.method_definition(
[INFO] [stdout] 3447 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3457 |                 accessibility,
[INFO] [stdout] 3458 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PropertyDefinition`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3482:13
[INFO] [stdout]      |
[INFO] [stdout] 3482 | /             self.property_definition(
[INFO] [stdout] 3483 | |                 span,
[INFO] [stdout] 3484 | |                 decorators,
[INFO] [stdout] 3485 | |                 key,
[INFO] [stdout] ...    |
[INFO] [stdout] 3499 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3498 -             )
[INFO] [stdout] 3499 -             .into(),
[INFO] [stdout] 3498 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3482 ~             <js::PropertyDefinition as Into<_>>::into(self.property_definition(
[INFO] [stdout] 3483 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3497 |                 accessibility,
[INFO] [stdout] 3498 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StaticBlock`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3504:35
[INFO] [stdout]      |
[INFO] [stdout] 3504 |         ClassElement::StaticBlock(self.static_block(span, body).into())
[INFO] [stdout]      |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3504 -         ClassElement::StaticBlock(self.static_block(span, body).into())
[INFO] [stdout] 3504 +         ClassElement::StaticBlock(self.static_block(span, body))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3504 -         ClassElement::StaticBlock(self.static_block(span, body).into())
[INFO] [stdout] 3504 +         ClassElement::StaticBlock(<js::StaticBlock as Into<_>>::into(self.static_block(span, body)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsMethodDefinition`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3522:13
[INFO] [stdout]      |
[INFO] [stdout] 3522 | /             self.ts_method_definition(
[INFO] [stdout] 3523 | |                 span,
[INFO] [stdout] 3524 | |                 decorators,
[INFO] [stdout] 3525 | |                 key,
[INFO] [stdout] ...    |
[INFO] [stdout] 3535 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3534 -             )
[INFO] [stdout] 3535 -             .into(),
[INFO] [stdout] 3534 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3522 ~             <ts::TsMethodDefinition as Into<_>>::into(self.ts_method_definition(
[INFO] [stdout] 3523 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3533 |                 accessibility,
[INFO] [stdout] 3534 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIndexSignature`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3548:13
[INFO] [stdout]      |
[INFO] [stdout] 3548 | /             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 3549 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3548 -             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 3549 -                 .into(),
[INFO] [stdout] 3548 +             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3548 -             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 3549 -                 .into(),
[INFO] [stdout] 3548 +             <ts::TsIndexSignature as Into<_>>::into(self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportSpecifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3561:13
[INFO] [stdout]      |
[INFO] [stdout] 3561 | /             self.import_specifier(span, imported, local, import_kind)
[INFO] [stdout] 3562 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3561 -             self.import_specifier(span, imported, local, import_kind)
[INFO] [stdout] 3562 -                 .into(),
[INFO] [stdout] 3561 +             self.import_specifier(span, imported, local, import_kind),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3561 -             self.import_specifier(span, imported, local, import_kind)
[INFO] [stdout] 3562 -                 .into(),
[INFO] [stdout] 3561 +             <js::ImportSpecifier as Into<_>>::into(self.import_specifier(span, imported, local, import_kind)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportDefaultSpecifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3572:13
[INFO] [stdout]      |
[INFO] [stdout] 3572 |             self.import_default_specifier(span, local).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3572 -             self.import_default_specifier(span, local).into(),
[INFO] [stdout] 3572 +             self.import_default_specifier(span, local),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3572 -             self.import_default_specifier(span, local).into(),
[INFO] [stdout] 3572 +             <js::ImportDefaultSpecifier as Into<_>>::into(self.import_default_specifier(span, local)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportNamespaceSpecifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3582:13
[INFO] [stdout]      |
[INFO] [stdout] 3582 |             self.import_namespace_specifier(span, local).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3582 -             self.import_namespace_specifier(span, local).into(),
[INFO] [stdout] 3582 +             self.import_namespace_specifier(span, local),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3582 -             self.import_namespace_specifier(span, local).into(),
[INFO] [stdout] 3582 +             <js::ImportNamespaceSpecifier as Into<_>>::into(self.import_namespace_specifier(span, local)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3592:13
[INFO] [stdout]      |
[INFO] [stdout] 3592 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3592 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 3592 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3592 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 3592 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3600:65
[INFO] [stdout]      |
[INFO] [stdout] 3600 |         ExportDefaultDeclarationKind::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3600 -         ExportDefaultDeclarationKind::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 3600 +         ExportDefaultDeclarationKind::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3600 -         ExportDefaultDeclarationKind::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 3600 +         ExportDefaultDeclarationKind::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3607:56
[INFO] [stdout]      |
[INFO] [stdout] 3607 |         ExportDefaultDeclarationKind::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3607 -         ExportDefaultDeclarationKind::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 3607 +         ExportDefaultDeclarationKind::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3607 -         ExportDefaultDeclarationKind::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 3607 +         ExportDefaultDeclarationKind::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3617:13
[INFO] [stdout]      |
[INFO] [stdout] 3617 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3617 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 3617 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3617 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 3617 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3628:13
[INFO] [stdout]      |
[INFO] [stdout] 3628 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3628 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 3628 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3628 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 3628 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3639:13
[INFO] [stdout]      |
[INFO] [stdout] 3639 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3639 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 3639 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3639 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 3639 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3649:13
[INFO] [stdout]      |
[INFO] [stdout] 3649 |             self.big_int_literal(span, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3649 -             self.big_int_literal(span, raw).into(),
[INFO] [stdout] 3649 +             self.big_int_literal(span, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3649 -             self.big_int_literal(span, raw).into(),
[INFO] [stdout] 3649 +             <js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3659:13
[INFO] [stdout]      |
[INFO] [stdout] 3659 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3659 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 3659 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3659 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 3659 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3667:62
[INFO] [stdout]      |
[INFO] [stdout] 3667 |         ExportDefaultDeclarationKind::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3667 -         ExportDefaultDeclarationKind::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 3667 +         ExportDefaultDeclarationKind::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3667 -         ExportDefaultDeclarationKind::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 3667 +         ExportDefaultDeclarationKind::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3677:13
[INFO] [stdout]      |
[INFO] [stdout] 3677 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3677 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 3677 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3677 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 3677 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3688:13
[INFO] [stdout]      |
[INFO] [stdout] 3688 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3688 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 3688 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3688 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 3688 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3700:13
[INFO] [stdout]      |
[INFO] [stdout] 3700 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3700 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 3700 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3700 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 3700 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3712:13
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3712 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 3712 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3712 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 3712 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3723:13
[INFO] [stdout]      |
[INFO] [stdout] 3723 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3723 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 3723 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3723 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 3723 +             <js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UpdateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3735:13
[INFO] [stdout]      |
[INFO] [stdout] 3735 | /             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3736 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3735 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3736 -                 .into(),
[INFO] [stdout] 3735 +             self.update_expression(span, argument, operator, prefix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3735 -             self.update_expression(span, argument, operator, prefix)
[INFO] [stdout] 3736 -                 .into(),
[INFO] [stdout] 3735 +             <js::UpdateExpression as Into<_>>::into(self.update_expression(span, argument, operator, prefix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AssignmentExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3748:13
[INFO] [stdout]      |
[INFO] [stdout] 3748 | /             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3749 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3748 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3749 -                 .into(),
[INFO] [stdout] 3748 +             self.assignment_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3748 -             self.assignment_expression(span, left, right, operator)
[INFO] [stdout] 3749 -                 .into(),
[INFO] [stdout] 3748 +             <js::AssignmentExpression as Into<_>>::into(self.assignment_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ConditionalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3761:13
[INFO] [stdout]      |
[INFO] [stdout] 3761 | /             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3762 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3761 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3762 -                 .into(),
[INFO] [stdout] 3761 +             self.conditional_expression(span, test, consequent, alternate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3761 -             self.conditional_expression(span, test, consequent, alternate)
[INFO] [stdout] 3762 -                 .into(),
[INFO] [stdout] 3761 +             <js::ConditionalExpression as Into<_>>::into(self.conditional_expression(span, test, consequent, alternate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::SequenceExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3772:13
[INFO] [stdout]      |
[INFO] [stdout] 3772 |             self.sequence_expression(span, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3772 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 3772 +             self.sequence_expression(span, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3772 -             self.sequence_expression(span, expressions).into(),
[INFO] [stdout] 3772 +             <js::SequenceExpression as Into<_>>::into(self.sequence_expression(span, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3785:13
[INFO] [stdout]      |
[INFO] [stdout] 3785 | /             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3786 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3785 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3786 -                 .into(),
[INFO] [stdout] 3785 +             self.member_expression(span, object, property, computed, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3785 -             self.member_expression(span, object, property, computed, optional)
[INFO] [stdout] 3786 -                 .into(),
[INFO] [stdout] 3785 +             <js::MemberExpression as Into<_>>::into(self.member_expression(span, object, property, computed, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::CallExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3799:13
[INFO] [stdout]      |
[INFO] [stdout] 3799 | /             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3800 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3799 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3800 -                 .into(),
[INFO] [stdout] 3799 +             self.call_expression(span, callee, type_arguments, arguments, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3799 -             self.call_expression(span, callee, type_arguments, arguments, optional)
[INFO] [stdout] 3800 -                 .into(),
[INFO] [stdout] 3799 +             <js::CallExpression as Into<_>>::into(self.call_expression(span, callee, type_arguments, arguments, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ChainExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3810:13
[INFO] [stdout]      |
[INFO] [stdout] 3810 |             self.chain_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3810 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 3810 +             self.chain_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3810 -             self.chain_expression(span, expression).into(),
[INFO] [stdout] 3810 +             <js::ChainExpression as Into<_>>::into(self.chain_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NewExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3822:13
[INFO] [stdout]      |
[INFO] [stdout] 3822 | /             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3823 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3822 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3823 -                 .into(),
[INFO] [stdout] 3822 +             self.new_expression(span, callee, type_arguments, arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3822 -             self.new_expression(span, callee, type_arguments, arguments)
[INFO] [stdout] 3823 -                 .into(),
[INFO] [stdout] 3822 +             <js::NewExpression as Into<_>>::into(self.new_expression(span, callee, type_arguments, arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TaggedTemplateExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3835:13
[INFO] [stdout]      |
[INFO] [stdout] 3835 | /             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3836 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3835 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3836 -                 .into(),
[INFO] [stdout] 3835 +             self.tagged_template_expression(span, tag, type_arguments, quasi),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3835 -             self.tagged_template_expression(span, tag, type_arguments, quasi)
[INFO] [stdout] 3836 -                 .into(),
[INFO] [stdout] 3835 +             <js::TaggedTemplateExpression as Into<_>>::into(self.tagged_template_expression(span, tag, type_arguments, quasi)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrowFunctionExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3851:13
[INFO] [stdout]      |
[INFO] [stdout] 3851 | /             self.arrow_function_expression(
[INFO] [stdout] 3852 | |                 span,
[INFO] [stdout] 3853 | |                 expression,
[INFO] [stdout] 3854 | |                 r#async,
[INFO] [stdout] ...    |
[INFO] [stdout] 3860 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3859 -             )
[INFO] [stdout] 3860 -             .into(),
[INFO] [stdout] 3859 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3851 ~             <js::ArrowFunctionExpression as Into<_>>::into(self.arrow_function_expression(
[INFO] [stdout] 3852 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3858 |                 body,
[INFO] [stdout] 3859 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ArrayExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3870:13
[INFO] [stdout]      |
[INFO] [stdout] 3870 |             self.array_expression(span, elements).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3870 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 3870 +             self.array_expression(span, elements),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3870 -             self.array_expression(span, elements).into(),
[INFO] [stdout] 3870 +             <js::ArrayExpression as Into<_>>::into(self.array_expression(span, elements)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ObjectExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3880:13
[INFO] [stdout]      |
[INFO] [stdout] 3880 |             self.object_expression(span, properties).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3880 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 3880 +             self.object_expression(span, properties),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3880 -             self.object_expression(span, properties).into(),
[INFO] [stdout] 3880 +             <js::ObjectExpression as Into<_>>::into(self.object_expression(span, properties)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ParenthesizedExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3890:13
[INFO] [stdout]      |
[INFO] [stdout] 3890 |             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3890 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 3890 +             self.parenthesized_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3890 -             self.parenthesized_expression(span, expression).into(),
[INFO] [stdout] 3890 +             <js::ParenthesizedExpression as Into<_>>::into(self.parenthesized_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3908:13
[INFO] [stdout]      |
[INFO] [stdout] 3908 | /             self.function(
[INFO] [stdout] 3909 | |                 span,
[INFO] [stdout] 3910 | |                 function_type,
[INFO] [stdout] 3911 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 3920 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3919 -             )
[INFO] [stdout] 3920 -             .into(),
[INFO] [stdout] 3919 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3908 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 3909 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3918 |                 r#async,
[INFO] [stdout] 3919 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3939:13
[INFO] [stdout]      |
[INFO] [stdout] 3939 | /             self.class(
[INFO] [stdout] 3940 | |                 span,
[INFO] [stdout] 3941 | |                 class_type,
[INFO] [stdout] 3942 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 3952 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3951 -             )
[INFO] [stdout] 3952 -             .into(),
[INFO] [stdout] 3951 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3939 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 3940 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 3950 |                 declare,
[INFO] [stdout] 3951 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ImportExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3965:13
[INFO] [stdout]      |
[INFO] [stdout] 3965 | /             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3966 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3965 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3966 -                 .into(),
[INFO] [stdout] 3965 +             self.import_expression(span, source, options, phase, sync),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3965 -             self.import_expression(span, source, options, phase, sync)
[INFO] [stdout] 3966 -                 .into(),
[INFO] [stdout] 3965 +             <js::ImportExpression as Into<_>>::into(self.import_expression(span, source, options, phase, sync)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::AwaitExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3976:13
[INFO] [stdout]      |
[INFO] [stdout] 3976 |             self.await_expression(span, argument).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3976 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 3976 +             self.await_expression(span, argument),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3976 -             self.await_expression(span, argument).into(),
[INFO] [stdout] 3976 +             <js::AwaitExpression as Into<_>>::into(self.await_expression(span, argument)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::YieldExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3987:13
[INFO] [stdout]      |
[INFO] [stdout] 3987 |             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3987 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 3987 +             self.yield_expression(span, argument, delegate),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3987 -             self.yield_expression(span, argument, delegate).into(),
[INFO] [stdout] 3987 +             <js::YieldExpression as Into<_>>::into(self.yield_expression(span, argument, delegate)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::PrivateIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:3997:13
[INFO] [stdout]      |
[INFO] [stdout] 3997 |             self.private_identifier(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3997 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 3997 +             self.private_identifier(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3997 -             self.private_identifier(span, name).into(),
[INFO] [stdout] 3997 +             <js::PrivateIdentifier as Into<_>>::into(self.private_identifier(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAsExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4008:13
[INFO] [stdout]      |
[INFO] [stdout] 4008 | /             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 4009 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4008 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 4009 -                 .into(),
[INFO] [stdout] 4008 +             self.ts_as_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4008 -             self.ts_as_expression(span, expression, type_annotation)
[INFO] [stdout] 4009 -                 .into(),
[INFO] [stdout] 4008 +             <ts::TsAsExpression as Into<_>>::into(self.ts_as_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSatisfiesExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4020:13
[INFO] [stdout]      |
[INFO] [stdout] 4020 | /             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 4021 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4020 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 4021 -                 .into(),
[INFO] [stdout] 4020 +             self.ts_satisfies_expression(span, expression, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4020 -             self.ts_satisfies_expression(span, expression, type_annotation)
[INFO] [stdout] 4021 -                 .into(),
[INFO] [stdout] 4020 +             <ts::TsSatisfiesExpression as Into<_>>::into(self.ts_satisfies_expression(span, expression, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeAssertion`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4032:13
[INFO] [stdout]      |
[INFO] [stdout] 4032 | /             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 4033 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 4033 -                 .into(),
[INFO] [stdout] 4032 +             self.ts_type_assertion(span, type_annotation, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             self.ts_type_assertion(span, type_annotation, expression)
[INFO] [stdout] 4033 -                 .into(),
[INFO] [stdout] 4032 +             <ts::TsTypeAssertion as Into<_>>::into(self.ts_type_assertion(span, type_annotation, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNonNullExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4043:13
[INFO] [stdout]      |
[INFO] [stdout] 4043 |             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4043 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 4043 +             self.ts_non_null_expression(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4043 -             self.ts_non_null_expression(span, expression).into(),
[INFO] [stdout] 4043 +             <ts::TsNonNullExpression as Into<_>>::into(self.ts_non_null_expression(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInstantiationExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4054:13
[INFO] [stdout]      |
[INFO] [stdout] 4054 | /             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 4055 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4054 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 4055 -                 .into(),
[INFO] [stdout] 4054 +             self.ts_instantiation_expression(span, expression, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4054 -             self.ts_instantiation_expression(span, expression, type_arguments)
[INFO] [stdout] 4055 -                 .into(),
[INFO] [stdout] 4054 +             <ts::TsInstantiationExpression as Into<_>>::into(self.ts_instantiation_expression(span, expression, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4067:13
[INFO] [stdout]      |
[INFO] [stdout] 4067 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 4068 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4067 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 4068 -                 .into(),
[INFO] [stdout] 4067 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4067 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 4068 -                 .into(),
[INFO] [stdout] 4067 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4080:13
[INFO] [stdout]      |
[INFO] [stdout] 4080 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 4081 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4080 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 4081 -                 .into(),
[INFO] [stdout] 4080 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4080 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 4081 -                 .into(),
[INFO] [stdout] 4080 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Function`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4099:13
[INFO] [stdout]      |
[INFO] [stdout] 4099 | /             self.function(
[INFO] [stdout] 4100 | |                 span,
[INFO] [stdout] 4101 | |                 function_type,
[INFO] [stdout] 4102 | |                 id,
[INFO] [stdout] ...    |
[INFO] [stdout] 4111 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4110 -             )
[INFO] [stdout] 4111 -             .into(),
[INFO] [stdout] 4110 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4099 ~             <js::Function as Into<_>>::into(self.function(
[INFO] [stdout] 4100 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 4109 |                 r#async,
[INFO] [stdout] 4110 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Class`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4130:13
[INFO] [stdout]      |
[INFO] [stdout] 4130 | /             self.class(
[INFO] [stdout] 4131 | |                 span,
[INFO] [stdout] 4132 | |                 class_type,
[INFO] [stdout] 4133 | |                 decorators,
[INFO] [stdout] ...    |
[INFO] [stdout] 4143 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4142 -             )
[INFO] [stdout] 4143 -             .into(),
[INFO] [stdout] 4142 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4130 ~             <js::Class as Into<_>>::into(self.class(
[INFO] [stdout] 4131 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 4141 |                 declare,
[INFO] [stdout] 4142 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsFunction`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4160:13
[INFO] [stdout]      |
[INFO] [stdout] 4160 | /             self.ts_function(
[INFO] [stdout] 4161 | |                 span,
[INFO] [stdout] 4162 | |                 id,
[INFO] [stdout] 4163 | |                 type_parameters,
[INFO] [stdout] ...    |
[INFO] [stdout] 4171 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4170 -             )
[INFO] [stdout] 4171 -             .into(),
[INFO] [stdout] 4170 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4160 ~             <ts::TsFunction as Into<_>>::into(self.ts_function(
[INFO] [stdout] 4161 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 4169 |                 declare,
[INFO] [stdout] 4170 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInterfaceDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:4185:13
[INFO] [stdout]      |
[INFO] [stdout] 4185 | /             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 4186 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4185 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 4186 -                 .into(),
[INFO] [stdout] 4185 +             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4185 -             self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)
[INFO] [stdout] 4186 -                 .into(),
[INFO] [stdout] 4185 +             <ts::TsInterfaceDeclaration as Into<_>>::into(self.ts_interface_declaration(span, id, type_parameters, extends, body, declare)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAnyKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5797:30
[INFO] [stdout]      |
[INFO] [stdout] 5797 |         TsType::TsAnyKeyword(self.ts_any_keyword(span).into())
[INFO] [stdout]      |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5797 -         TsType::TsAnyKeyword(self.ts_any_keyword(span).into())
[INFO] [stdout] 5797 +         TsType::TsAnyKeyword(self.ts_any_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5797 -         TsType::TsAnyKeyword(self.ts_any_keyword(span).into())
[INFO] [stdout] 5797 +         TsType::TsAnyKeyword(<ts::TsAnyKeyword as Into<_>>::into(self.ts_any_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUnknownKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5801:34
[INFO] [stdout]      |
[INFO] [stdout] 5801 |         TsType::TsUnknownKeyword(self.ts_unknown_keyword(span).into())
[INFO] [stdout]      |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5801 -         TsType::TsUnknownKeyword(self.ts_unknown_keyword(span).into())
[INFO] [stdout] 5801 +         TsType::TsUnknownKeyword(self.ts_unknown_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5801 -         TsType::TsUnknownKeyword(self.ts_unknown_keyword(span).into())
[INFO] [stdout] 5801 +         TsType::TsUnknownKeyword(<ts::TsUnknownKeyword as Into<_>>::into(self.ts_unknown_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNeverKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5805:32
[INFO] [stdout]      |
[INFO] [stdout] 5805 |         TsType::TsNeverKeyword(self.ts_never_keyword(span).into())
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5805 -         TsType::TsNeverKeyword(self.ts_never_keyword(span).into())
[INFO] [stdout] 5805 +         TsType::TsNeverKeyword(self.ts_never_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5805 -         TsType::TsNeverKeyword(self.ts_never_keyword(span).into())
[INFO] [stdout] 5805 +         TsType::TsNeverKeyword(<ts::TsNeverKeyword as Into<_>>::into(self.ts_never_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsVoidKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5809:31
[INFO] [stdout]      |
[INFO] [stdout] 5809 |         TsType::TsVoidKeyword(self.ts_void_keyword(span).into())
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5809 -         TsType::TsVoidKeyword(self.ts_void_keyword(span).into())
[INFO] [stdout] 5809 +         TsType::TsVoidKeyword(self.ts_void_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5809 -         TsType::TsVoidKeyword(self.ts_void_keyword(span).into())
[INFO] [stdout] 5809 +         TsType::TsVoidKeyword(<ts::TsVoidKeyword as Into<_>>::into(self.ts_void_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNullKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5813:31
[INFO] [stdout]      |
[INFO] [stdout] 5813 |         TsType::TsNullKeyword(self.ts_null_keyword(span).into())
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5813 -         TsType::TsNullKeyword(self.ts_null_keyword(span).into())
[INFO] [stdout] 5813 +         TsType::TsNullKeyword(self.ts_null_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5813 -         TsType::TsNullKeyword(self.ts_null_keyword(span).into())
[INFO] [stdout] 5813 +         TsType::TsNullKeyword(<ts::TsNullKeyword as Into<_>>::into(self.ts_null_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUndefinedKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5817:36
[INFO] [stdout]      |
[INFO] [stdout] 5817 |         TsType::TsUndefinedKeyword(self.ts_undefined_keyword(span).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5817 -         TsType::TsUndefinedKeyword(self.ts_undefined_keyword(span).into())
[INFO] [stdout] 5817 +         TsType::TsUndefinedKeyword(self.ts_undefined_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5817 -         TsType::TsUndefinedKeyword(self.ts_undefined_keyword(span).into())
[INFO] [stdout] 5817 +         TsType::TsUndefinedKeyword(<ts::TsUndefinedKeyword as Into<_>>::into(self.ts_undefined_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsStringKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5821:33
[INFO] [stdout]      |
[INFO] [stdout] 5821 |         TsType::TsStringKeyword(self.ts_string_keyword(span).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5821 -         TsType::TsStringKeyword(self.ts_string_keyword(span).into())
[INFO] [stdout] 5821 +         TsType::TsStringKeyword(self.ts_string_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5821 -         TsType::TsStringKeyword(self.ts_string_keyword(span).into())
[INFO] [stdout] 5821 +         TsType::TsStringKeyword(<ts::TsStringKeyword as Into<_>>::into(self.ts_string_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNumberKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5825:33
[INFO] [stdout]      |
[INFO] [stdout] 5825 |         TsType::TsNumberKeyword(self.ts_number_keyword(span).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5825 -         TsType::TsNumberKeyword(self.ts_number_keyword(span).into())
[INFO] [stdout] 5825 +         TsType::TsNumberKeyword(self.ts_number_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5825 -         TsType::TsNumberKeyword(self.ts_number_keyword(span).into())
[INFO] [stdout] 5825 +         TsType::TsNumberKeyword(<ts::TsNumberKeyword as Into<_>>::into(self.ts_number_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsBigIntKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5829:33
[INFO] [stdout]      |
[INFO] [stdout] 5829 |         TsType::TsBigIntKeyword(self.ts_big_int_keyword(span).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5829 -         TsType::TsBigIntKeyword(self.ts_big_int_keyword(span).into())
[INFO] [stdout] 5829 +         TsType::TsBigIntKeyword(self.ts_big_int_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5829 -         TsType::TsBigIntKeyword(self.ts_big_int_keyword(span).into())
[INFO] [stdout] 5829 +         TsType::TsBigIntKeyword(<ts::TsBigIntKeyword as Into<_>>::into(self.ts_big_int_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsBooleanKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5833:34
[INFO] [stdout]      |
[INFO] [stdout] 5833 |         TsType::TsBooleanKeyword(self.ts_boolean_keyword(span).into())
[INFO] [stdout]      |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5833 -         TsType::TsBooleanKeyword(self.ts_boolean_keyword(span).into())
[INFO] [stdout] 5833 +         TsType::TsBooleanKeyword(self.ts_boolean_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5833 -         TsType::TsBooleanKeyword(self.ts_boolean_keyword(span).into())
[INFO] [stdout] 5833 +         TsType::TsBooleanKeyword(<ts::TsBooleanKeyword as Into<_>>::into(self.ts_boolean_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSymbolKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5837:33
[INFO] [stdout]      |
[INFO] [stdout] 5837 |         TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5837 -         TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into())
[INFO] [stdout] 5837 +         TsType::TsSymbolKeyword(self.ts_symbol_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5837 -         TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into())
[INFO] [stdout] 5837 +         TsType::TsSymbolKeyword(<ts::TsSymbolKeyword as Into<_>>::into(self.ts_symbol_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsObjectKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5841:33
[INFO] [stdout]      |
[INFO] [stdout] 5841 |         TsType::TsObjectKeyword(self.ts_object_keyword(span).into())
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5841 -         TsType::TsObjectKeyword(self.ts_object_keyword(span).into())
[INFO] [stdout] 5841 +         TsType::TsObjectKeyword(self.ts_object_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5841 -         TsType::TsObjectKeyword(self.ts_object_keyword(span).into())
[INFO] [stdout] 5841 +         TsType::TsObjectKeyword(<ts::TsObjectKeyword as Into<_>>::into(self.ts_object_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIntrinsicKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5845:36
[INFO] [stdout]      |
[INFO] [stdout] 5845 |         TsType::TsIntrinsicKeyword(self.ts_intrinsic_keyword(span).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5845 -         TsType::TsIntrinsicKeyword(self.ts_intrinsic_keyword(span).into())
[INFO] [stdout] 5845 +         TsType::TsIntrinsicKeyword(self.ts_intrinsic_keyword(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5845 -         TsType::TsIntrinsicKeyword(self.ts_intrinsic_keyword(span).into())
[INFO] [stdout] 5845 +         TsType::TsIntrinsicKeyword(<ts::TsIntrinsicKeyword as Into<_>>::into(self.ts_intrinsic_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsThisType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5849:28
[INFO] [stdout]      |
[INFO] [stdout] 5849 |         TsType::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout]      |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5849 -         TsType::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout] 5849 +         TsType::TsThisType(self.ts_this_type(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5849 -         TsType::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout] 5849 +         TsType::TsThisType(<ts::TsThisType as Into<_>>::into(self.ts_this_type(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5859:13
[INFO] [stdout]      |
[INFO] [stdout] 5859 | /             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 5860 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5859 -             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 5860 -                 .into(),
[INFO] [stdout] 5859 +             self.ts_type_reference(span, type_name, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5859 -             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 5860 -                 .into(),
[INFO] [stdout] 5859 +             <ts::TsTypeReference as Into<_>>::into(self.ts_type_reference(span, type_name, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeQuery`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5870:29
[INFO] [stdout]      |
[INFO] [stdout] 5870 |         TsType::TsTypeQuery(self.ts_type_query(span, expr_name, type_arguments).into())
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5870 -         TsType::TsTypeQuery(self.ts_type_query(span, expr_name, type_arguments).into())
[INFO] [stdout] 5870 +         TsType::TsTypeQuery(self.ts_type_query(span, expr_name, type_arguments))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5870 -         TsType::TsTypeQuery(self.ts_type_query(span, expr_name, type_arguments).into())
[INFO] [stdout] 5870 +         TsType::TsTypeQuery(<ts::TsTypeQuery as Into<_>>::into(self.ts_type_query(span, expr_name, type_arguments)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsImportType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5882:13
[INFO] [stdout]      |
[INFO] [stdout] 5882 | /             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 5883 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5882 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 5883 -                 .into(),
[INFO] [stdout] 5882 +             self.ts_import_type(span, source, options, qualifier, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5882 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 5883 -                 .into(),
[INFO] [stdout] 5882 +             <ts::TsImportType as Into<_>>::into(self.ts_import_type(span, source, options, qualifier, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsLiteralType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5888:31
[INFO] [stdout]      |
[INFO] [stdout] 5888 |         TsType::TsLiteralType(self.ts_literal_type(span, literal).into())
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5888 -         TsType::TsLiteralType(self.ts_literal_type(span, literal).into())
[INFO] [stdout] 5888 +         TsType::TsLiteralType(self.ts_literal_type(span, literal))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5888 -         TsType::TsLiteralType(self.ts_literal_type(span, literal).into())
[INFO] [stdout] 5888 +         TsType::TsLiteralType(<ts::TsLiteralType as Into<_>>::into(self.ts_literal_type(span, literal)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTemplateLiteralType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5897:39
[INFO] [stdout]      |
[INFO] [stdout] 5897 |         TsType::TsTemplateLiteralType(self.ts_template_literal_type(span, quasis, types).into())
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5897 -         TsType::TsTemplateLiteralType(self.ts_template_literal_type(span, quasis, types).into())
[INFO] [stdout] 5897 +         TsType::TsTemplateLiteralType(self.ts_template_literal_type(span, quasis, types))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5897 -         TsType::TsTemplateLiteralType(self.ts_template_literal_type(span, quasis, types).into())
[INFO] [stdout] 5897 +         TsType::TsTemplateLiteralType(<ts::TsTemplateLiteralType as Into<_>>::into(self.ts_template_literal_type(span, quasis, types)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsArrayType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5901:29
[INFO] [stdout]      |
[INFO] [stdout] 5901 |         TsType::TsArrayType(self.ts_array_type(span, element_type).into())
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5901 -         TsType::TsArrayType(self.ts_array_type(span, element_type).into())
[INFO] [stdout] 5901 +         TsType::TsArrayType(self.ts_array_type(span, element_type))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5901 -         TsType::TsArrayType(self.ts_array_type(span, element_type).into())
[INFO] [stdout] 5901 +         TsType::TsArrayType(<ts::TsArrayType as Into<_>>::into(self.ts_array_type(span, element_type)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIndexedAccessType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5911:13
[INFO] [stdout]      |
[INFO] [stdout] 5911 | /             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 5912 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5911 -             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 5912 -                 .into(),
[INFO] [stdout] 5911 +             self.ts_indexed_access_type(span, object_type, index_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5911 -             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 5912 -                 .into(),
[INFO] [stdout] 5911 +             <ts::TsIndexedAccessType as Into<_>>::into(self.ts_indexed_access_type(span, object_type, index_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTupleType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5921:29
[INFO] [stdout]      |
[INFO] [stdout] 5921 |         TsType::TsTupleType(self.ts_tuple_type(span, element_types).into())
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5921 -         TsType::TsTupleType(self.ts_tuple_type(span, element_types).into())
[INFO] [stdout] 5921 +         TsType::TsTupleType(self.ts_tuple_type(span, element_types))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5921 -         TsType::TsTupleType(self.ts_tuple_type(span, element_types).into())
[INFO] [stdout] 5921 +         TsType::TsTupleType(<ts::TsTupleType as Into<_>>::into(self.ts_tuple_type(span, element_types)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsOptionalType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5925:32
[INFO] [stdout]      |
[INFO] [stdout] 5925 |         TsType::TsOptionalType(self.ts_optional_type(span, type_annotation).into())
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5925 -         TsType::TsOptionalType(self.ts_optional_type(span, type_annotation).into())
[INFO] [stdout] 5925 +         TsType::TsOptionalType(self.ts_optional_type(span, type_annotation))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5925 -         TsType::TsOptionalType(self.ts_optional_type(span, type_annotation).into())
[INFO] [stdout] 5925 +         TsType::TsOptionalType(<ts::TsOptionalType as Into<_>>::into(self.ts_optional_type(span, type_annotation)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsRestType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5929:28
[INFO] [stdout]      |
[INFO] [stdout] 5929 |         TsType::TsRestType(self.ts_rest_type(span, type_annotation).into())
[INFO] [stdout]      |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5929 -         TsType::TsRestType(self.ts_rest_type(span, type_annotation).into())
[INFO] [stdout] 5929 +         TsType::TsRestType(self.ts_rest_type(span, type_annotation))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5929 -         TsType::TsRestType(self.ts_rest_type(span, type_annotation).into())
[INFO] [stdout] 5929 +         TsType::TsRestType(<ts::TsRestType as Into<_>>::into(self.ts_rest_type(span, type_annotation)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocNullableType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5939:13
[INFO] [stdout]      |
[INFO] [stdout] 5939 | /             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5940 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5939 -             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5940 -                 .into(),
[INFO] [stdout] 5939 +             self.ts_js_doc_nullable_type(span, type_annotation, postfix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5939 -             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5940 -                 .into(),
[INFO] [stdout] 5939 +             <ts::TsJsDocNullableType as Into<_>>::into(self.ts_js_doc_nullable_type(span, type_annotation, postfix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocNonNullableType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5951:13
[INFO] [stdout]      |
[INFO] [stdout] 5951 | /             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5952 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5951 -             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5952 -                 .into(),
[INFO] [stdout] 5951 +             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5951 -             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 5952 -                 .into(),
[INFO] [stdout] 5951 +             <ts::TsJsDocNonNullableType as Into<_>>::into(self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocUnknownType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5957:36
[INFO] [stdout]      |
[INFO] [stdout] 5957 |         TsType::TsJsDocUnknownType(self.ts_js_doc_unknown_type(span).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5957 -         TsType::TsJsDocUnknownType(self.ts_js_doc_unknown_type(span).into())
[INFO] [stdout] 5957 +         TsType::TsJsDocUnknownType(self.ts_js_doc_unknown_type(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5957 -         TsType::TsJsDocUnknownType(self.ts_js_doc_unknown_type(span).into())
[INFO] [stdout] 5957 +         TsType::TsJsDocUnknownType(<ts::TsJsDocUnknownType as Into<_>>::into(self.ts_js_doc_unknown_type(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUnionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5961:29
[INFO] [stdout]      |
[INFO] [stdout] 5961 |         TsType::TsUnionType(self.ts_union_type(span, types).into())
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5961 -         TsType::TsUnionType(self.ts_union_type(span, types).into())
[INFO] [stdout] 5961 +         TsType::TsUnionType(self.ts_union_type(span, types))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5961 -         TsType::TsUnionType(self.ts_union_type(span, types).into())
[INFO] [stdout] 5961 +         TsType::TsUnionType(<ts::TsUnionType as Into<_>>::into(self.ts_union_type(span, types)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIntersectionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5965:36
[INFO] [stdout]      |
[INFO] [stdout] 5965 |         TsType::TsIntersectionType(self.ts_intersection_type(span, types).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5965 -         TsType::TsIntersectionType(self.ts_intersection_type(span, types).into())
[INFO] [stdout] 5965 +         TsType::TsIntersectionType(self.ts_intersection_type(span, types))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5965 -         TsType::TsIntersectionType(self.ts_intersection_type(span, types).into())
[INFO] [stdout] 5965 +         TsType::TsIntersectionType(<ts::TsIntersectionType as Into<_>>::into(self.ts_intersection_type(span, types)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsConditionalType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5977:13
[INFO] [stdout]      |
[INFO] [stdout] 5977 | /             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 5978 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5977 -             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 5978 -                 .into(),
[INFO] [stdout] 5977 +             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5977 -             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 5978 -                 .into(),
[INFO] [stdout] 5977 +             <ts::TsConditionalType as Into<_>>::into(self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInferType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5983:29
[INFO] [stdout]      |
[INFO] [stdout] 5983 |         TsType::TsInferType(self.ts_infer_type(span, type_parameter).into())
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5983 -         TsType::TsInferType(self.ts_infer_type(span, type_parameter).into())
[INFO] [stdout] 5983 +         TsType::TsInferType(self.ts_infer_type(span, type_parameter))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5983 -         TsType::TsInferType(self.ts_infer_type(span, type_parameter).into())
[INFO] [stdout] 5983 +         TsType::TsInferType(<ts::TsInferType as Into<_>>::into(self.ts_infer_type(span, type_parameter)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeOperator`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5993:13
[INFO] [stdout]      |
[INFO] [stdout] 5993 | /             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 5994 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5993 -             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 5994 -                 .into(),
[INFO] [stdout] 5993 +             self.ts_type_operator(span, operator, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5993 -             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 5994 -                 .into(),
[INFO] [stdout] 5993 +             <ts::TsTypeOperator as Into<_>>::into(self.ts_type_operator(span, operator, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsParenthesizedType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:5999:37
[INFO] [stdout]      |
[INFO] [stdout] 5999 |         TsType::TsParenthesizedType(self.ts_parenthesized_type(span, type_annotation).into())
[INFO] [stdout]      |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5999 -         TsType::TsParenthesizedType(self.ts_parenthesized_type(span, type_annotation).into())
[INFO] [stdout] 5999 +         TsType::TsParenthesizedType(self.ts_parenthesized_type(span, type_annotation))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5999 -         TsType::TsParenthesizedType(self.ts_parenthesized_type(span, type_annotation).into())
[INFO] [stdout] 5999 +         TsType::TsParenthesizedType(<ts::TsParenthesizedType as Into<_>>::into(self.ts_parenthesized_type(span, type_annotation)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsFunctionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6011:13
[INFO] [stdout]      |
[INFO] [stdout] 6011 | /             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6012 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6011 -             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6012 -                 .into(),
[INFO] [stdout] 6011 +             self.ts_function_type(span, type_parameters, this_param, params, return_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6011 -             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6012 -                 .into(),
[INFO] [stdout] 6011 +             <ts::TsFunctionType as Into<_>>::into(self.ts_function_type(span, type_parameters, this_param, params, return_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsConstructorType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6025:13
[INFO] [stdout]      |
[INFO] [stdout] 6025 | /             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6026 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6025 -             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6026 -                 .into(),
[INFO] [stdout] 6025 +             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6025 -             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6026 -                 .into(),
[INFO] [stdout] 6025 +             <ts::TsConstructorType as Into<_>>::into(self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypePredicate`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6038:13
[INFO] [stdout]      |
[INFO] [stdout] 6038 | /             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6039 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6038 -             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6039 -                 .into(),
[INFO] [stdout] 6038 +             self.ts_type_predicate(span, parameter_name, type_annotation, asserts),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6038 -             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6039 -                 .into(),
[INFO] [stdout] 6038 +             <ts::TsTypePredicate as Into<_>>::into(self.ts_type_predicate(span, parameter_name, type_annotation, asserts)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6048:31
[INFO] [stdout]      |
[INFO] [stdout] 6048 |         TsType::TsTypeLiteral(self.ts_type_literal(span, members).into())
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6048 -         TsType::TsTypeLiteral(self.ts_type_literal(span, members).into())
[INFO] [stdout] 6048 +         TsType::TsTypeLiteral(self.ts_type_literal(span, members))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6048 -         TsType::TsTypeLiteral(self.ts_type_literal(span, members).into())
[INFO] [stdout] 6048 +         TsType::TsTypeLiteral(<ts::TsTypeLiteral as Into<_>>::into(self.ts_type_literal(span, members)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsMappedType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6062:13
[INFO] [stdout]      |
[INFO] [stdout] 6062 | /             self.ts_mapped_type(
[INFO] [stdout] 6063 | |                 span,
[INFO] [stdout] 6064 | |                 key,
[INFO] [stdout] 6065 | |                 constraint,
[INFO] [stdout] ...    |
[INFO] [stdout] 6071 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6070 -             )
[INFO] [stdout] 6071 -             .into(),
[INFO] [stdout] 6070 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6062 ~             <ts::TsMappedType as Into<_>>::into(self.ts_mapped_type(
[INFO] [stdout] 6063 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 6069 |                 readonly,
[INFO] [stdout] 6070 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6076:41
[INFO] [stdout]      |
[INFO] [stdout] 6076 |         TsTypeName::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6076 -         TsTypeName::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 6076 +         TsTypeName::IdentifierReference(self.identifier_reference(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6076 -         TsTypeName::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 6076 +         TsTypeName::IdentifierReference(<js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6085:37
[INFO] [stdout]      |
[INFO] [stdout] 6085 |         TsTypeName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout]      |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6085 -         TsTypeName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6085 +         TsTypeName::TsQualifiedName(self.ts_qualified_name(span, left, right))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6085 -         TsTypeName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6085 +         TsTypeName::TsQualifiedName(<ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6093:50
[INFO] [stdout]      |
[INFO] [stdout] 6093 |         TsQualifiedNameLeft::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6093 -         TsQualifiedNameLeft::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 6093 +         TsQualifiedNameLeft::IdentifierReference(self.identifier_reference(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6093 -         TsQualifiedNameLeft::IdentifierReference(self.identifier_reference(span, name).into())
[INFO] [stdout] 6093 +         TsQualifiedNameLeft::IdentifierReference(<js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6101:45
[INFO] [stdout]      |
[INFO] [stdout] 6101 |         TsQualifiedNameLeft::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6101 -         TsQualifiedNameLeft::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6101 +         TsQualifiedNameLeft::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6101 -         TsQualifiedNameLeft::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6101 +         TsQualifiedNameLeft::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BindingIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6109:48
[INFO] [stdout]      |
[INFO] [stdout] 6109 |         TsQualifiedNameLeft::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6109 -         TsQualifiedNameLeft::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 6109 +         TsQualifiedNameLeft::BindingIdentifier(self.binding_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6109 -         TsQualifiedNameLeft::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 6109 +         TsQualifiedNameLeft::BindingIdentifier(<js::BindingIdentifier as Into<_>>::into(self.binding_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6113:45
[INFO] [stdout]      |
[INFO] [stdout] 6113 |         TsQualifiedNameLeft::ThisExpression(self.this_expression(span).into())
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6113 -         TsQualifiedNameLeft::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 6113 +         TsQualifiedNameLeft::ThisExpression(self.this_expression(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6113 -         TsQualifiedNameLeft::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 6113 +         TsQualifiedNameLeft::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6122:46
[INFO] [stdout]      |
[INFO] [stdout] 6122 |         TsQualifiedNameLeft::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6122 -         TsQualifiedNameLeft::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6122 +         TsQualifiedNameLeft::TsQualifiedName(self.ts_qualified_name(span, left, right))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6122 -         TsQualifiedNameLeft::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6122 +         TsQualifiedNameLeft::TsQualifiedName(<ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6130:47
[INFO] [stdout]      |
[INFO] [stdout] 6130 |         TsImportTypeQualifier::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6130 -         TsImportTypeQualifier::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6130 +         TsImportTypeQualifier::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6130 -         TsImportTypeQualifier::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6130 +         TsImportTypeQualifier::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6139:48
[INFO] [stdout]      |
[INFO] [stdout] 6139 |         TsImportTypeQualifier::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6139 -         TsImportTypeQualifier::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6139 +         TsImportTypeQualifier::TsQualifiedName(self.ts_qualified_name(span, left, right))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6139 -         TsImportTypeQualifier::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6139 +         TsImportTypeQualifier::TsQualifiedName(<ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6148:13
[INFO] [stdout]      |
[INFO] [stdout] 6148 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6148 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 6148 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6148 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 6148 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6159:13
[INFO] [stdout]      |
[INFO] [stdout] 6159 |             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6159 -             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout] 6159 +             self.ts_qualified_name(span, left, right),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6159 -             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout] 6159 +             <ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6164:45
[INFO] [stdout]      |
[INFO] [stdout] 6164 |         TsTypeQueryExprName::ThisExpression(self.this_expression(span).into())
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6164 -         TsTypeQueryExprName::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 6164 +         TsTypeQueryExprName::ThisExpression(self.this_expression(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6164 -         TsTypeQueryExprName::ThisExpression(self.this_expression(span).into())
[INFO] [stdout] 6164 +         TsTypeQueryExprName::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsImportType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6176:13
[INFO] [stdout]      |
[INFO] [stdout] 6176 | /             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6177 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6176 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6177 -                 .into(),
[INFO] [stdout] 6176 +             self.ts_import_type(span, source, options, qualifier, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6176 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6177 -                 .into(),
[INFO] [stdout] 6176 +             <ts::TsImportType as Into<_>>::into(self.ts_import_type(span, source, options, qualifier, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6187:34
[INFO] [stdout]      |
[INFO] [stdout] 6187 |         TsLiteral::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]      |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6187 -         TsLiteral::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6187 +         TsLiteral::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6187 -         TsLiteral::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6187 +         TsLiteral::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6196:35
[INFO] [stdout]      |
[INFO] [stdout] 6196 |         TsLiteral::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout]      |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6196 -         TsLiteral::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout] 6196 +         TsLiteral::NumericLiteral(self.numeric_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6196 -         TsLiteral::NumericLiteral(self.numeric_literal(span, value, raw).into())
[INFO] [stdout] 6196 +         TsLiteral::NumericLiteral(<js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6200:34
[INFO] [stdout]      |
[INFO] [stdout] 6200 |         TsLiteral::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout]      |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6200 -         TsLiteral::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout] 6200 +         TsLiteral::BigIntLiteral(self.big_int_literal(span, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6200 -         TsLiteral::BigIntLiteral(self.big_int_literal(span, raw).into())
[INFO] [stdout] 6200 +         TsLiteral::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6204:35
[INFO] [stdout]      |
[INFO] [stdout] 6204 |         TsLiteral::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout]      |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6204 -         TsLiteral::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout] 6204 +         TsLiteral::BooleanLiteral(self.boolean_literal(span, value))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6204 -         TsLiteral::BooleanLiteral(self.boolean_literal(span, value).into())
[INFO] [stdout] 6204 +         TsLiteral::BooleanLiteral(<js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6213:36
[INFO] [stdout]      |
[INFO] [stdout] 6213 |         TsLiteral::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6213 -         TsLiteral::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 6213 +         TsLiteral::TemplateLiteral(self.template_literal(span, quasis, expressions))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6213 -         TsLiteral::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 6213 +         TsLiteral::TemplateLiteral(<js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6222:36
[INFO] [stdout]      |
[INFO] [stdout] 6222 |         TsLiteral::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout]      |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6222 -         TsLiteral::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout] 6222 +         TsLiteral::UnaryExpression(self.unary_expression(span, argument, operator))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6222 -         TsLiteral::UnaryExpression(self.unary_expression(span, argument, operator).into())
[INFO] [stdout] 6222 +         TsLiteral::UnaryExpression(<js::UnaryExpression as Into<_>>::into(self.unary_expression(span, argument, operator)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsAnyKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6226:53
[INFO] [stdout]      |
[INFO] [stdout] 6226 |         TsTupleElement::TsType(TsType::TsAnyKeyword(self.ts_any_keyword(span).into()))
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6226 -         TsTupleElement::TsType(TsType::TsAnyKeyword(self.ts_any_keyword(span).into()))
[INFO] [stdout] 6226 +         TsTupleElement::TsType(TsType::TsAnyKeyword(self.ts_any_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6226 -         TsTupleElement::TsType(TsType::TsAnyKeyword(self.ts_any_keyword(span).into()))
[INFO] [stdout] 6226 +         TsTupleElement::TsType(TsType::TsAnyKeyword(<ts::TsAnyKeyword as Into<_>>::into(self.ts_any_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUnknownKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6231:13
[INFO] [stdout]      |
[INFO] [stdout] 6231 |             self.ts_unknown_keyword(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6231 -             self.ts_unknown_keyword(span).into(),
[INFO] [stdout] 6231 +             self.ts_unknown_keyword(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6231 -             self.ts_unknown_keyword(span).into(),
[INFO] [stdout] 6231 +             <ts::TsUnknownKeyword as Into<_>>::into(self.ts_unknown_keyword(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNeverKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6236:55
[INFO] [stdout]      |
[INFO] [stdout] 6236 |         TsTupleElement::TsType(TsType::TsNeverKeyword(self.ts_never_keyword(span).into()))
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6236 -         TsTupleElement::TsType(TsType::TsNeverKeyword(self.ts_never_keyword(span).into()))
[INFO] [stdout] 6236 +         TsTupleElement::TsType(TsType::TsNeverKeyword(self.ts_never_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6236 -         TsTupleElement::TsType(TsType::TsNeverKeyword(self.ts_never_keyword(span).into()))
[INFO] [stdout] 6236 +         TsTupleElement::TsType(TsType::TsNeverKeyword(<ts::TsNeverKeyword as Into<_>>::into(self.ts_never_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsVoidKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6240:54
[INFO] [stdout]      |
[INFO] [stdout] 6240 |         TsTupleElement::TsType(TsType::TsVoidKeyword(self.ts_void_keyword(span).into()))
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6240 -         TsTupleElement::TsType(TsType::TsVoidKeyword(self.ts_void_keyword(span).into()))
[INFO] [stdout] 6240 +         TsTupleElement::TsType(TsType::TsVoidKeyword(self.ts_void_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6240 -         TsTupleElement::TsType(TsType::TsVoidKeyword(self.ts_void_keyword(span).into()))
[INFO] [stdout] 6240 +         TsTupleElement::TsType(TsType::TsVoidKeyword(<ts::TsVoidKeyword as Into<_>>::into(self.ts_void_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNullKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6244:54
[INFO] [stdout]      |
[INFO] [stdout] 6244 |         TsTupleElement::TsType(TsType::TsNullKeyword(self.ts_null_keyword(span).into()))
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6244 -         TsTupleElement::TsType(TsType::TsNullKeyword(self.ts_null_keyword(span).into()))
[INFO] [stdout] 6244 +         TsTupleElement::TsType(TsType::TsNullKeyword(self.ts_null_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6244 -         TsTupleElement::TsType(TsType::TsNullKeyword(self.ts_null_keyword(span).into()))
[INFO] [stdout] 6244 +         TsTupleElement::TsType(TsType::TsNullKeyword(<ts::TsNullKeyword as Into<_>>::into(self.ts_null_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUndefinedKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6249:13
[INFO] [stdout]      |
[INFO] [stdout] 6249 |             self.ts_undefined_keyword(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6249 -             self.ts_undefined_keyword(span).into(),
[INFO] [stdout] 6249 +             self.ts_undefined_keyword(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6249 -             self.ts_undefined_keyword(span).into(),
[INFO] [stdout] 6249 +             <ts::TsUndefinedKeyword as Into<_>>::into(self.ts_undefined_keyword(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsStringKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6254:56
[INFO] [stdout]      |
[INFO] [stdout] 6254 |         TsTupleElement::TsType(TsType::TsStringKeyword(self.ts_string_keyword(span).into()))
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6254 -         TsTupleElement::TsType(TsType::TsStringKeyword(self.ts_string_keyword(span).into()))
[INFO] [stdout] 6254 +         TsTupleElement::TsType(TsType::TsStringKeyword(self.ts_string_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6254 -         TsTupleElement::TsType(TsType::TsStringKeyword(self.ts_string_keyword(span).into()))
[INFO] [stdout] 6254 +         TsTupleElement::TsType(TsType::TsStringKeyword(<ts::TsStringKeyword as Into<_>>::into(self.ts_string_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNumberKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6258:56
[INFO] [stdout]      |
[INFO] [stdout] 6258 |         TsTupleElement::TsType(TsType::TsNumberKeyword(self.ts_number_keyword(span).into()))
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6258 -         TsTupleElement::TsType(TsType::TsNumberKeyword(self.ts_number_keyword(span).into()))
[INFO] [stdout] 6258 +         TsTupleElement::TsType(TsType::TsNumberKeyword(self.ts_number_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6258 -         TsTupleElement::TsType(TsType::TsNumberKeyword(self.ts_number_keyword(span).into()))
[INFO] [stdout] 6258 +         TsTupleElement::TsType(TsType::TsNumberKeyword(<ts::TsNumberKeyword as Into<_>>::into(self.ts_number_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsBigIntKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6263:13
[INFO] [stdout]      |
[INFO] [stdout] 6263 |             self.ts_big_int_keyword(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6263 -             self.ts_big_int_keyword(span).into(),
[INFO] [stdout] 6263 +             self.ts_big_int_keyword(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6263 -             self.ts_big_int_keyword(span).into(),
[INFO] [stdout] 6263 +             <ts::TsBigIntKeyword as Into<_>>::into(self.ts_big_int_keyword(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsBooleanKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6269:13
[INFO] [stdout]      |
[INFO] [stdout] 6269 |             self.ts_boolean_keyword(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6269 -             self.ts_boolean_keyword(span).into(),
[INFO] [stdout] 6269 +             self.ts_boolean_keyword(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6269 -             self.ts_boolean_keyword(span).into(),
[INFO] [stdout] 6269 +             <ts::TsBooleanKeyword as Into<_>>::into(self.ts_boolean_keyword(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsSymbolKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6274:56
[INFO] [stdout]      |
[INFO] [stdout] 6274 |         TsTupleElement::TsType(TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into()))
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6274 -         TsTupleElement::TsType(TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into()))
[INFO] [stdout] 6274 +         TsTupleElement::TsType(TsType::TsSymbolKeyword(self.ts_symbol_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6274 -         TsTupleElement::TsType(TsType::TsSymbolKeyword(self.ts_symbol_keyword(span).into()))
[INFO] [stdout] 6274 +         TsTupleElement::TsType(TsType::TsSymbolKeyword(<ts::TsSymbolKeyword as Into<_>>::into(self.ts_symbol_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsObjectKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6278:56
[INFO] [stdout]      |
[INFO] [stdout] 6278 |         TsTupleElement::TsType(TsType::TsObjectKeyword(self.ts_object_keyword(span).into()))
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6278 -         TsTupleElement::TsType(TsType::TsObjectKeyword(self.ts_object_keyword(span).into()))
[INFO] [stdout] 6278 +         TsTupleElement::TsType(TsType::TsObjectKeyword(self.ts_object_keyword(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6278 -         TsTupleElement::TsType(TsType::TsObjectKeyword(self.ts_object_keyword(span).into()))
[INFO] [stdout] 6278 +         TsTupleElement::TsType(TsType::TsObjectKeyword(<ts::TsObjectKeyword as Into<_>>::into(self.ts_object_keyword(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIntrinsicKeyword`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6283:13
[INFO] [stdout]      |
[INFO] [stdout] 6283 |             self.ts_intrinsic_keyword(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6283 -             self.ts_intrinsic_keyword(span).into(),
[INFO] [stdout] 6283 +             self.ts_intrinsic_keyword(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6283 -             self.ts_intrinsic_keyword(span).into(),
[INFO] [stdout] 6283 +             <ts::TsIntrinsicKeyword as Into<_>>::into(self.ts_intrinsic_keyword(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsThisType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6288:51
[INFO] [stdout]      |
[INFO] [stdout] 6288 |         TsTupleElement::TsType(TsType::TsThisType(self.ts_this_type(span).into()))
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6288 -         TsTupleElement::TsType(TsType::TsThisType(self.ts_this_type(span).into()))
[INFO] [stdout] 6288 +         TsTupleElement::TsType(TsType::TsThisType(self.ts_this_type(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6288 -         TsTupleElement::TsType(TsType::TsThisType(self.ts_this_type(span).into()))
[INFO] [stdout] 6288 +         TsTupleElement::TsType(TsType::TsThisType(<ts::TsThisType as Into<_>>::into(self.ts_this_type(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6298:13
[INFO] [stdout]      |
[INFO] [stdout] 6298 | /             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 6299 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6298 -             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 6299 -                 .into(),
[INFO] [stdout] 6298 +             self.ts_type_reference(span, type_name, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6298 -             self.ts_type_reference(span, type_name, type_arguments)
[INFO] [stdout] 6299 -                 .into(),
[INFO] [stdout] 6298 +             <ts::TsTypeReference as Into<_>>::into(self.ts_type_reference(span, type_name, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeQuery`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6310:13
[INFO] [stdout]      |
[INFO] [stdout] 6310 |             self.ts_type_query(span, expr_name, type_arguments).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6310 -             self.ts_type_query(span, expr_name, type_arguments).into(),
[INFO] [stdout] 6310 +             self.ts_type_query(span, expr_name, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6310 -             self.ts_type_query(span, expr_name, type_arguments).into(),
[INFO] [stdout] 6310 +             <ts::TsTypeQuery as Into<_>>::into(self.ts_type_query(span, expr_name, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsImportType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6323:13
[INFO] [stdout]      |
[INFO] [stdout] 6323 | /             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6324 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6323 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6324 -                 .into(),
[INFO] [stdout] 6323 +             self.ts_import_type(span, source, options, qualifier, type_arguments),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6323 -             self.ts_import_type(span, source, options, qualifier, type_arguments)
[INFO] [stdout] 6324 -                 .into(),
[INFO] [stdout] 6323 +             <ts::TsImportType as Into<_>>::into(self.ts_import_type(span, source, options, qualifier, type_arguments)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsLiteralType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6334:13
[INFO] [stdout]      |
[INFO] [stdout] 6334 |             self.ts_literal_type(span, literal).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6334 -             self.ts_literal_type(span, literal).into(),
[INFO] [stdout] 6334 +             self.ts_literal_type(span, literal),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6334 -             self.ts_literal_type(span, literal).into(),
[INFO] [stdout] 6334 +             <ts::TsLiteralType as Into<_>>::into(self.ts_literal_type(span, literal)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTemplateLiteralType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6345:13
[INFO] [stdout]      |
[INFO] [stdout] 6345 |             self.ts_template_literal_type(span, quasis, types).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6345 -             self.ts_template_literal_type(span, quasis, types).into(),
[INFO] [stdout] 6345 +             self.ts_template_literal_type(span, quasis, types),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6345 -             self.ts_template_literal_type(span, quasis, types).into(),
[INFO] [stdout] 6345 +             <ts::TsTemplateLiteralType as Into<_>>::into(self.ts_template_literal_type(span, quasis, types)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsArrayType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6355:13
[INFO] [stdout]      |
[INFO] [stdout] 6355 |             self.ts_array_type(span, element_type).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6355 -             self.ts_array_type(span, element_type).into(),
[INFO] [stdout] 6355 +             self.ts_array_type(span, element_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6355 -             self.ts_array_type(span, element_type).into(),
[INFO] [stdout] 6355 +             <ts::TsArrayType as Into<_>>::into(self.ts_array_type(span, element_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIndexedAccessType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6366:13
[INFO] [stdout]      |
[INFO] [stdout] 6366 | /             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 6367 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6366 -             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 6367 -                 .into(),
[INFO] [stdout] 6366 +             self.ts_indexed_access_type(span, object_type, index_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6366 -             self.ts_indexed_access_type(span, object_type, index_type)
[INFO] [stdout] 6367 -                 .into(),
[INFO] [stdout] 6366 +             <ts::TsIndexedAccessType as Into<_>>::into(self.ts_indexed_access_type(span, object_type, index_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTupleType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6377:13
[INFO] [stdout]      |
[INFO] [stdout] 6377 |             self.ts_tuple_type(span, element_types).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6377 -             self.ts_tuple_type(span, element_types).into(),
[INFO] [stdout] 6377 +             self.ts_tuple_type(span, element_types),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6377 -             self.ts_tuple_type(span, element_types).into(),
[INFO] [stdout] 6377 +             <ts::TsTupleType as Into<_>>::into(self.ts_tuple_type(span, element_types)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsOptionalType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6387:13
[INFO] [stdout]      |
[INFO] [stdout] 6387 |             self.ts_optional_type(span, type_annotation).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6387 -             self.ts_optional_type(span, type_annotation).into(),
[INFO] [stdout] 6387 +             self.ts_optional_type(span, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6387 -             self.ts_optional_type(span, type_annotation).into(),
[INFO] [stdout] 6387 +             <ts::TsOptionalType as Into<_>>::into(self.ts_optional_type(span, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsRestType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6397:13
[INFO] [stdout]      |
[INFO] [stdout] 6397 |             self.ts_rest_type(span, type_annotation).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6397 -             self.ts_rest_type(span, type_annotation).into(),
[INFO] [stdout] 6397 +             self.ts_rest_type(span, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6397 -             self.ts_rest_type(span, type_annotation).into(),
[INFO] [stdout] 6397 +             <ts::TsRestType as Into<_>>::into(self.ts_rest_type(span, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocNullableType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6408:13
[INFO] [stdout]      |
[INFO] [stdout] 6408 | /             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6409 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6408 -             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6409 -                 .into(),
[INFO] [stdout] 6408 +             self.ts_js_doc_nullable_type(span, type_annotation, postfix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6408 -             self.ts_js_doc_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6409 -                 .into(),
[INFO] [stdout] 6408 +             <ts::TsJsDocNullableType as Into<_>>::into(self.ts_js_doc_nullable_type(span, type_annotation, postfix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocNonNullableType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6420:13
[INFO] [stdout]      |
[INFO] [stdout] 6420 | /             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6421 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6420 -             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6421 -                 .into(),
[INFO] [stdout] 6420 +             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6420 -             self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)
[INFO] [stdout] 6421 -                 .into(),
[INFO] [stdout] 6420 +             <ts::TsJsDocNonNullableType as Into<_>>::into(self.ts_js_doc_non_nullable_type(span, type_annotation, postfix)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsJsDocUnknownType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6430:13
[INFO] [stdout]      |
[INFO] [stdout] 6430 |             self.ts_js_doc_unknown_type(span).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6430 -             self.ts_js_doc_unknown_type(span).into(),
[INFO] [stdout] 6430 +             self.ts_js_doc_unknown_type(span),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6430 -             self.ts_js_doc_unknown_type(span).into(),
[INFO] [stdout] 6430 +             <ts::TsJsDocUnknownType as Into<_>>::into(self.ts_js_doc_unknown_type(span)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsUnionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6439:52
[INFO] [stdout]      |
[INFO] [stdout] 6439 |         TsTupleElement::TsType(TsType::TsUnionType(self.ts_union_type(span, types).into()))
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6439 -         TsTupleElement::TsType(TsType::TsUnionType(self.ts_union_type(span, types).into()))
[INFO] [stdout] 6439 +         TsTupleElement::TsType(TsType::TsUnionType(self.ts_union_type(span, types)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6439 -         TsTupleElement::TsType(TsType::TsUnionType(self.ts_union_type(span, types).into()))
[INFO] [stdout] 6439 +         TsTupleElement::TsType(TsType::TsUnionType(<ts::TsUnionType as Into<_>>::into(self.ts_union_type(span, types))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIntersectionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6448:13
[INFO] [stdout]      |
[INFO] [stdout] 6448 |             self.ts_intersection_type(span, types).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6448 -             self.ts_intersection_type(span, types).into(),
[INFO] [stdout] 6448 +             self.ts_intersection_type(span, types),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6448 -             self.ts_intersection_type(span, types).into(),
[INFO] [stdout] 6448 +             <ts::TsIntersectionType as Into<_>>::into(self.ts_intersection_type(span, types)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsConditionalType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6461:13
[INFO] [stdout]      |
[INFO] [stdout] 6461 | /             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 6462 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6461 -             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 6462 -                 .into(),
[INFO] [stdout] 6461 +             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6461 -             self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)
[INFO] [stdout] 6462 -                 .into(),
[INFO] [stdout] 6461 +             <ts::TsConditionalType as Into<_>>::into(self.ts_conditional_type(span, check_type, extends_type, true_type, false_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsInferType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6472:13
[INFO] [stdout]      |
[INFO] [stdout] 6472 |             self.ts_infer_type(span, type_parameter).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6472 -             self.ts_infer_type(span, type_parameter).into(),
[INFO] [stdout] 6472 +             self.ts_infer_type(span, type_parameter),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6472 -             self.ts_infer_type(span, type_parameter).into(),
[INFO] [stdout] 6472 +             <ts::TsInferType as Into<_>>::into(self.ts_infer_type(span, type_parameter)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeOperator`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6483:13
[INFO] [stdout]      |
[INFO] [stdout] 6483 | /             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 6484 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6483 -             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 6484 -                 .into(),
[INFO] [stdout] 6483 +             self.ts_type_operator(span, operator, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6483 -             self.ts_type_operator(span, operator, type_annotation)
[INFO] [stdout] 6484 -                 .into(),
[INFO] [stdout] 6483 +             <ts::TsTypeOperator as Into<_>>::into(self.ts_type_operator(span, operator, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsParenthesizedType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6494:13
[INFO] [stdout]      |
[INFO] [stdout] 6494 |             self.ts_parenthesized_type(span, type_annotation).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6494 -             self.ts_parenthesized_type(span, type_annotation).into(),
[INFO] [stdout] 6494 +             self.ts_parenthesized_type(span, type_annotation),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6494 -             self.ts_parenthesized_type(span, type_annotation).into(),
[INFO] [stdout] 6494 +             <ts::TsParenthesizedType as Into<_>>::into(self.ts_parenthesized_type(span, type_annotation)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsFunctionType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6507:13
[INFO] [stdout]      |
[INFO] [stdout] 6507 | /             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6508 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6507 -             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6508 -                 .into(),
[INFO] [stdout] 6507 +             self.ts_function_type(span, type_parameters, this_param, params, return_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6507 -             self.ts_function_type(span, type_parameters, this_param, params, return_type)
[INFO] [stdout] 6508 -                 .into(),
[INFO] [stdout] 6507 +             <ts::TsFunctionType as Into<_>>::into(self.ts_function_type(span, type_parameters, this_param, params, return_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsConstructorType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6521:13
[INFO] [stdout]      |
[INFO] [stdout] 6521 | /             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6522 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6521 -             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6522 -                 .into(),
[INFO] [stdout] 6521 +             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6521 -             self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)
[INFO] [stdout] 6522 -                 .into(),
[INFO] [stdout] 6521 +             <ts::TsConstructorType as Into<_>>::into(self.ts_constructor_type(span, type_parameters, params, return_type, r#abstract)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypePredicate`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6534:13
[INFO] [stdout]      |
[INFO] [stdout] 6534 | /             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6535 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6534 -             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6535 -                 .into(),
[INFO] [stdout] 6534 +             self.ts_type_predicate(span, parameter_name, type_annotation, asserts),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6534 -             self.ts_type_predicate(span, parameter_name, type_annotation, asserts)
[INFO] [stdout] 6535 -                 .into(),
[INFO] [stdout] 6534 +             <ts::TsTypePredicate as Into<_>>::into(self.ts_type_predicate(span, parameter_name, type_annotation, asserts)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsTypeLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6545:13
[INFO] [stdout]      |
[INFO] [stdout] 6545 |             self.ts_type_literal(span, members).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6545 -             self.ts_type_literal(span, members).into(),
[INFO] [stdout] 6545 +             self.ts_type_literal(span, members),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6545 -             self.ts_type_literal(span, members).into(),
[INFO] [stdout] 6545 +             <ts::TsTypeLiteral as Into<_>>::into(self.ts_type_literal(span, members)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsMappedType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6560:13
[INFO] [stdout]      |
[INFO] [stdout] 6560 | /             self.ts_mapped_type(
[INFO] [stdout] 6561 | |                 span,
[INFO] [stdout] 6562 | |                 key,
[INFO] [stdout] 6563 | |                 constraint,
[INFO] [stdout] ...    |
[INFO] [stdout] 6569 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6568 -             )
[INFO] [stdout] 6569 -             .into(),
[INFO] [stdout] 6568 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6560 ~             <ts::TsMappedType as Into<_>>::into(self.ts_mapped_type(
[INFO] [stdout] 6561 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 6567 |                 readonly,
[INFO] [stdout] 6568 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsNamedTupleMember`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6581:13
[INFO] [stdout]      |
[INFO] [stdout] 6581 | /             self.ts_named_tuple_member(span, label, element_type, optional)
[INFO] [stdout] 6582 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6581 -             self.ts_named_tuple_member(span, label, element_type, optional)
[INFO] [stdout] 6582 -                 .into(),
[INFO] [stdout] 6581 +             self.ts_named_tuple_member(span, label, element_type, optional),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6581 -             self.ts_named_tuple_member(span, label, element_type, optional)
[INFO] [stdout] 6582 -                 .into(),
[INFO] [stdout] 6581 +             <ts::TsNamedTupleMember as Into<_>>::into(self.ts_named_tuple_member(span, label, element_type, optional)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsPropertySignature`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6596:13
[INFO] [stdout]      |
[INFO] [stdout] 6596 | /             self.ts_property_signature(span, key, type_annotation, computed, optional, readonly)
[INFO] [stdout] 6597 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6596 -             self.ts_property_signature(span, key, type_annotation, computed, optional, readonly)
[INFO] [stdout] 6597 -                 .into(),
[INFO] [stdout] 6596 +             self.ts_property_signature(span, key, type_annotation, computed, optional, readonly),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6596 -             self.ts_property_signature(span, key, type_annotation, computed, optional, readonly)
[INFO] [stdout] 6597 -                 .into(),
[INFO] [stdout] 6596 +             <ts::TsPropertySignature as Into<_>>::into(self.ts_property_signature(span, key, type_annotation, computed, optional, readonly)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsMethodSignature`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6614:13
[INFO] [stdout]      |
[INFO] [stdout] 6614 | /             self.ts_method_signature(
[INFO] [stdout] 6615 | |                 span,
[INFO] [stdout] 6616 | |                 key,
[INFO] [stdout] 6617 | |                 type_parameters,
[INFO] [stdout] ...    |
[INFO] [stdout] 6625 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6624 -             )
[INFO] [stdout] 6625 -             .into(),
[INFO] [stdout] 6624 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6614 ~             <ts::TsMethodSignature as Into<_>>::into(self.ts_method_signature(
[INFO] [stdout] 6615 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 6623 |                 optional,
[INFO] [stdout] 6624 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsCallSignatureDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6638:13
[INFO] [stdout]      |
[INFO] [stdout] 6638 | /             self.ts_call_signature_declaration(
[INFO] [stdout] 6639 | |                 span,
[INFO] [stdout] 6640 | |                 type_parameters,
[INFO] [stdout] 6641 | |                 this_param,
[INFO] [stdout] ...    |
[INFO] [stdout] 6645 | |             .into(),
[INFO] [stdout]      | |___________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6644 -             )
[INFO] [stdout] 6645 -             .into(),
[INFO] [stdout] 6644 +             ),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6638 ~             <ts::TsCallSignatureDeclaration as Into<_>>::into(self.ts_call_signature_declaration(
[INFO] [stdout] 6639 |                 span,
[INFO] [stdout]  ...
[INFO] [stdout] 6643 |                 return_type,
[INFO] [stdout] 6644 ~             )),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsConstructSignatureDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6657:13
[INFO] [stdout]      |
[INFO] [stdout] 6657 | /             self.ts_construct_signature_declaration(span, type_parameters, params, return_type)
[INFO] [stdout] 6658 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6657 -             self.ts_construct_signature_declaration(span, type_parameters, params, return_type)
[INFO] [stdout] 6658 -                 .into(),
[INFO] [stdout] 6657 +             self.ts_construct_signature_declaration(span, type_parameters, params, return_type),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6657 -             self.ts_construct_signature_declaration(span, type_parameters, params, return_type)
[INFO] [stdout] 6658 -                 .into(),
[INFO] [stdout] 6657 +             <ts::TsConstructSignatureDeclaration as Into<_>>::into(self.ts_construct_signature_declaration(span, type_parameters, params, return_type)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsIndexSignature`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6671:13
[INFO] [stdout]      |
[INFO] [stdout] 6671 | /             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 6672 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6671 -             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 6672 -                 .into(),
[INFO] [stdout] 6671 +             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6671 -             self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)
[INFO] [stdout] 6672 -                 .into(),
[INFO] [stdout] 6671 +             <ts::TsIndexSignature as Into<_>>::into(self.ts_index_signature(span, parameters, type_annotation, readonly, r#static)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6681:45
[INFO] [stdout]      |
[INFO] [stdout] 6681 |         TsTypePredicateName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6681 -         TsTypePredicateName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6681 +         TsTypePredicateName::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6681 -         TsTypePredicateName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6681 +         TsTypePredicateName::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsThisType`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6685:41
[INFO] [stdout]      |
[INFO] [stdout] 6685 |         TsTypePredicateName::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6685 -         TsTypePredicateName::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout] 6685 +         TsTypePredicateName::TsThisType(self.ts_this_type(span))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6685 -         TsTypePredicateName::TsThisType(self.ts_this_type(span).into())
[INFO] [stdout] 6685 +         TsTypePredicateName::TsThisType(<ts::TsThisType as Into<_>>::into(self.ts_this_type(span)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6693:42
[INFO] [stdout]      |
[INFO] [stdout] 6693 |         TsEnumMemberName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6693 -         TsEnumMemberName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6693 +         TsEnumMemberName::IdentifierName(self.identifier_name(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6693 -         TsEnumMemberName::IdentifierName(self.identifier_name(span, name).into())
[INFO] [stdout] 6693 +         TsEnumMemberName::IdentifierName(<js::IdentifierName as Into<_>>::into(self.identifier_name(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6702:41
[INFO] [stdout]      |
[INFO] [stdout] 6702 |         TsEnumMemberName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6702 -         TsEnumMemberName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6702 +         TsEnumMemberName::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6702 -         TsEnumMemberName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6702 +         TsEnumMemberName::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6711:43
[INFO] [stdout]      |
[INFO] [stdout] 6711 |         TsEnumMemberName::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6711 -         TsEnumMemberName::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 6711 +         TsEnumMemberName::TemplateLiteral(self.template_literal(span, quasis, expressions))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6711 -         TsEnumMemberName::TemplateLiteral(self.template_literal(span, quasis, expressions).into())
[INFO] [stdout] 6711 +         TsEnumMemberName::TemplateLiteral(<js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BindingIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6715:41
[INFO] [stdout]      |
[INFO] [stdout] 6715 |         TsModuleName::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6715 -         TsModuleName::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 6715 +         TsModuleName::BindingIdentifier(self.binding_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6715 -         TsModuleName::BindingIdentifier(self.binding_identifier(span, name).into())
[INFO] [stdout] 6715 +         TsModuleName::BindingIdentifier(<js::BindingIdentifier as Into<_>>::into(self.binding_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6724:37
[INFO] [stdout]      |
[INFO] [stdout] 6724 |         TsModuleName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]      |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6724 -         TsModuleName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6724 +         TsModuleName::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6724 -         TsModuleName::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 6724 +         TsModuleName::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6733:39
[INFO] [stdout]      |
[INFO] [stdout] 6733 |         TsModuleName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6733 -         TsModuleName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6733 +         TsModuleName::TsQualifiedName(self.ts_qualified_name(span, left, right))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6733 -         TsModuleName::TsQualifiedName(self.ts_qualified_name(span, left, right).into())
[INFO] [stdout] 6733 +         TsModuleName::TsQualifiedName(<ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsModuleBlock`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6742:37
[INFO] [stdout]      |
[INFO] [stdout] 6742 |         TsModuleBody::TsModuleBlock(self.ts_module_block(span, directives, body).into())
[INFO] [stdout]      |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6742 -         TsModuleBody::TsModuleBlock(self.ts_module_block(span, directives, body).into())
[INFO] [stdout] 6742 +         TsModuleBody::TsModuleBlock(self.ts_module_block(span, directives, body))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6742 -         TsModuleBody::TsModuleBlock(self.ts_module_block(span, directives, body).into())
[INFO] [stdout] 6742 +         TsModuleBody::TsModuleBlock(<ts::TsModuleBlock as Into<_>>::into(self.ts_module_block(span, directives, body)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsModuleDeclaration`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6754:13
[INFO] [stdout]      |
[INFO] [stdout] 6754 | /             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 6755 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6754 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 6755 -                 .into(),
[INFO] [stdout] 6754 +             self.ts_module_declaration(span, id, body, kind, declare),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6754 -             self.ts_module_declaration(span, id, body, kind, declare)
[INFO] [stdout] 6755 -                 .into(),
[INFO] [stdout] 6754 +             <ts::TsModuleDeclaration as Into<_>>::into(self.ts_module_declaration(span, id, body, kind, declare)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6765:13
[INFO] [stdout]      |
[INFO] [stdout] 6765 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6765 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 6765 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6765 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 6765 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsQualifiedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6776:13
[INFO] [stdout]      |
[INFO] [stdout] 6776 |             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6776 -             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout] 6776 +             self.ts_qualified_name(span, left, right),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6776 -             self.ts_qualified_name(span, left, right).into(),
[INFO] [stdout] 6776 +             <ts::TsQualifiedName as Into<_>>::into(self.ts_qualified_name(span, left, right)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ts::TsExternalModuleReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:6786:13
[INFO] [stdout]      |
[INFO] [stdout] 6786 |             self.ts_external_module_reference(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6786 -             self.ts_external_module_reference(span, expression).into(),
[INFO] [stdout] 6786 +             self.ts_external_module_reference(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6786 -             self.ts_external_module_reference(span, expression).into(),
[INFO] [stdout] 6786 +             <ts::TsExternalModuleReference as Into<_>>::into(self.ts_external_module_reference(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8044:39
[INFO] [stdout]      |
[INFO] [stdout] 8044 |         JsxElementName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8044 -         JsxElementName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8044 +         JsxElementName::JsxIdentifier(self.jsx_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8044 -         JsxElementName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8044 +         JsxElementName::JsxIdentifier(<jsx::JsxIdentifier as Into<_>>::into(self.jsx_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxNamespacedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8053:43
[INFO] [stdout]      |
[INFO] [stdout] 8053 |         JsxElementName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8053 -         JsxElementName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout] 8053 +         JsxElementName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8053 -         JsxElementName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout] 8053 +         JsxElementName::JsxNamespacedName(<jsx::JsxNamespacedName as Into<_>>::into(self.jsx_namespaced_name(span, namespace, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxMemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8063:13
[INFO] [stdout]      |
[INFO] [stdout] 8063 |             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8063 -             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout] 8063 +             self.jsx_member_expression(span, object, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8063 -             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout] 8063 +             <jsx::JsxMemberExpression as Into<_>>::into(self.jsx_member_expression(span, object, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8072:50
[INFO] [stdout]      |
[INFO] [stdout] 8072 |         JsxMemberExpressionObject::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8072 -         JsxMemberExpressionObject::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8072 +         JsxMemberExpressionObject::JsxIdentifier(self.jsx_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8072 -         JsxMemberExpressionObject::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8072 +         JsxMemberExpressionObject::JsxIdentifier(<jsx::JsxIdentifier as Into<_>>::into(self.jsx_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxMemberExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8082:13
[INFO] [stdout]      |
[INFO] [stdout] 8082 |             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8082 -             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout] 8082 +             self.jsx_member_expression(span, object, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8082 -             self.jsx_member_expression(span, object, property).into(),
[INFO] [stdout] 8082 +             <jsx::JsxMemberExpression as Into<_>>::into(self.jsx_member_expression(span, object, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxIdentifier`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8091:41
[INFO] [stdout]      |
[INFO] [stdout] 8091 |         JsxAttributeName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8091 -         JsxAttributeName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8091 +         JsxAttributeName::JsxIdentifier(self.jsx_identifier(span, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8091 -         JsxAttributeName::JsxIdentifier(self.jsx_identifier(span, name).into())
[INFO] [stdout] 8091 +         JsxAttributeName::JsxIdentifier(<jsx::JsxIdentifier as Into<_>>::into(self.jsx_identifier(span, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxNamespacedName`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8100:45
[INFO] [stdout]      |
[INFO] [stdout] 8100 |         JsxAttributeName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8100 -         JsxAttributeName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout] 8100 +         JsxAttributeName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8100 -         JsxAttributeName::JsxNamespacedName(self.jsx_namespaced_name(span, namespace, name).into())
[INFO] [stdout] 8100 +         JsxAttributeName::JsxNamespacedName(<jsx::JsxNamespacedName as Into<_>>::into(self.jsx_namespaced_name(span, namespace, name)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxAttribute`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8109:40
[INFO] [stdout]      |
[INFO] [stdout] 8109 |         JsxAttributeItem::JsxAttribute(self.jsx_attribute(span, name, value).into())
[INFO] [stdout]      |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8109 -         JsxAttributeItem::JsxAttribute(self.jsx_attribute(span, name, value).into())
[INFO] [stdout] 8109 +         JsxAttributeItem::JsxAttribute(self.jsx_attribute(span, name, value))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8109 -         JsxAttributeItem::JsxAttribute(self.jsx_attribute(span, name, value).into())
[INFO] [stdout] 8109 +         JsxAttributeItem::JsxAttribute(<jsx::JsxAttribute as Into<_>>::into(self.jsx_attribute(span, name, value)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxSpreadAttribute`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8117:46
[INFO] [stdout]      |
[INFO] [stdout] 8117 |         JsxAttributeItem::JsxSpreadAttribute(self.jsx_spread_attribute(span, argument).into())
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8117 -         JsxAttributeItem::JsxSpreadAttribute(self.jsx_spread_attribute(span, argument).into())
[INFO] [stdout] 8117 +         JsxAttributeItem::JsxSpreadAttribute(self.jsx_spread_attribute(span, argument))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8117 -         JsxAttributeItem::JsxSpreadAttribute(self.jsx_spread_attribute(span, argument).into())
[INFO] [stdout] 8117 +         JsxAttributeItem::JsxSpreadAttribute(<jsx::JsxSpreadAttribute as Into<_>>::into(self.jsx_spread_attribute(span, argument)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8126:42
[INFO] [stdout]      |
[INFO] [stdout] 8126 |         JsxAttributeValue::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8126 -         JsxAttributeValue::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 8126 +         JsxAttributeValue::StringLiteral(self.string_literal(span, value, raw))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8126 -         JsxAttributeValue::StringLiteral(self.string_literal(span, value, raw).into())
[INFO] [stdout] 8126 +         JsxAttributeValue::StringLiteral(<js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxExpressionContainer`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8135:13
[INFO] [stdout]      |
[INFO] [stdout] 8135 |             self.jsx_expression_container(span, expression).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8135 -             self.jsx_expression_container(span, expression).into(),
[INFO] [stdout] 8135 +             self.jsx_expression_container(span, expression),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8135 -             self.jsx_expression_container(span, expression).into(),
[INFO] [stdout] 8135 +             <jsx::JsxExpressionContainer as Into<_>>::into(self.jsx_expression_container(span, expression)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxElement`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8147:13
[INFO] [stdout]      |
[INFO] [stdout] 8147 | /             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 8148 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8147 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 8148 -                 .into(),
[INFO] [stdout] 8147 +             self.jsx_element(span, opening_element, children, closing_element),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8147 -             self.jsx_element(span, opening_element, children, closing_element)
[INFO] [stdout] 8148 -                 .into(),
[INFO] [stdout] 8147 +             <jsx::JsxElement as Into<_>>::into(self.jsx_element(span, opening_element, children, closing_element)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `jsx::JsxFragment`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8160:13
[INFO] [stdout]      |
[INFO] [stdout] 8160 | /             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 8161 | |                 .into(),
[INFO] [stdout]      | |_______________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8160 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 8161 -                 .into(),
[INFO] [stdout] 8160 +             self.jsx_fragment(span, opening_fragment, children, closing_fragment),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8160 -             self.jsx_fragment(span, opening_fragment, children, closing_fragment)
[INFO] [stdout] 8161 -                 .into(),
[INFO] [stdout] 8160 +             <jsx::JsxFragment as Into<_>>::into(self.jsx_fragment(span, opening_fragment, children, closing_fragment)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::IdentifierReference`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8171:13
[INFO] [stdout]      |
[INFO] [stdout] 8171 |             self.identifier_reference(span, name).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8171 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 8171 +             self.identifier_reference(span, name),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8171 -             self.identifier_reference(span, name).into(),
[INFO] [stdout] 8171 +             <js::IdentifierReference as Into<_>>::into(self.identifier_reference(span, name)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::ThisExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8176:50
[INFO] [stdout]      |
[INFO] [stdout] 8176 |         JsxExpression::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8176 -         JsxExpression::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 8176 +         JsxExpression::Expr(Expr::ThisExpression(self.this_expression(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8176 -         JsxExpression::Expr(Expr::ThisExpression(self.this_expression(span).into()))
[INFO] [stdout] 8176 +         JsxExpression::Expr(Expr::ThisExpression(<js::ThisExpression as Into<_>>::into(self.this_expression(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::Super`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8180:41
[INFO] [stdout]      |
[INFO] [stdout] 8180 |         JsxExpression::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8180 -         JsxExpression::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 8180 +         JsxExpression::Expr(Expr::Super(self.super_(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8180 -         JsxExpression::Expr(Expr::Super(self.super_(span).into()))
[INFO] [stdout] 8180 +         JsxExpression::Expr(Expr::Super(<js::Super as Into<_>>::into(self.super_(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::MetaProperty`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8190:13
[INFO] [stdout]      |
[INFO] [stdout] 8190 |             self.meta_property(span, meta, property).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8190 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 8190 +             self.meta_property(span, meta, property),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8190 -             self.meta_property(span, meta, property).into(),
[INFO] [stdout] 8190 +             <js::MetaProperty as Into<_>>::into(self.meta_property(span, meta, property)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::StringLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8201:13
[INFO] [stdout]      |
[INFO] [stdout] 8201 |             self.string_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8201 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 8201 +             self.string_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8201 -             self.string_literal(span, value, raw).into(),
[INFO] [stdout] 8201 +             <js::StringLiteral as Into<_>>::into(self.string_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NumericLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8212:13
[INFO] [stdout]      |
[INFO] [stdout] 8212 |             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8212 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 8212 +             self.numeric_literal(span, value, raw),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8212 -             self.numeric_literal(span, value, raw).into(),
[INFO] [stdout] 8212 +             <js::NumericLiteral as Into<_>>::into(self.numeric_literal(span, value, raw)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BigIntLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8221:49
[INFO] [stdout]      |
[INFO] [stdout] 8221 |         JsxExpression::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8221 -         JsxExpression::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 8221 +         JsxExpression::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8221 -         JsxExpression::Expr(Expr::BigIntLiteral(self.big_int_literal(span, raw).into()))
[INFO] [stdout] 8221 +         JsxExpression::Expr(Expr::BigIntLiteral(<js::BigIntLiteral as Into<_>>::into(self.big_int_literal(span, raw))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BooleanLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8230:13
[INFO] [stdout]      |
[INFO] [stdout] 8230 |             self.boolean_literal(span, value).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8230 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 8230 +             self.boolean_literal(span, value),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8230 -             self.boolean_literal(span, value).into(),
[INFO] [stdout] 8230 +             <js::BooleanLiteral as Into<_>>::into(self.boolean_literal(span, value)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::NullLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8235:47
[INFO] [stdout]      |
[INFO] [stdout] 8235 |         JsxExpression::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8235 -         JsxExpression::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 8235 +         JsxExpression::Expr(Expr::NullLiteral(self.null_literal(span)))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8235 -         JsxExpression::Expr(Expr::NullLiteral(self.null_literal(span).into()))
[INFO] [stdout] 8235 +         JsxExpression::Expr(Expr::NullLiteral(<js::NullLiteral as Into<_>>::into(self.null_literal(span))))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::RegExpLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8245:13
[INFO] [stdout]      |
[INFO] [stdout] 8245 |             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8245 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 8245 +             self.reg_exp_literal(span, pattern, flags),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8245 -             self.reg_exp_literal(span, pattern, flags).into(),
[INFO] [stdout] 8245 +             <js::RegExpLiteral as Into<_>>::into(self.reg_exp_literal(span, pattern, flags)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::TemplateLiteral`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8256:13
[INFO] [stdout]      |
[INFO] [stdout] 8256 |             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8256 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 8256 +             self.template_literal(span, quasis, expressions),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8256 -             self.template_literal(span, quasis, expressions).into(),
[INFO] [stdout] 8256 +             <js::TemplateLiteral as Into<_>>::into(self.template_literal(span, quasis, expressions)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::BinaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8268:13
[INFO] [stdout]      |
[INFO] [stdout] 8268 |             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8268 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 8268 +             self.binary_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8268 -             self.binary_expression(span, left, right, operator).into(),
[INFO] [stdout] 8268 +             <js::BinaryExpression as Into<_>>::into(self.binary_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::LogicalExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8280:13
[INFO] [stdout]      |
[INFO] [stdout] 8280 |             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8280 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 8280 +             self.logical_expression(span, left, right, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8280 -             self.logical_expression(span, left, right, operator).into(),
[INFO] [stdout] 8280 +             <js::LogicalExpression as Into<_>>::into(self.logical_expression(span, left, right, operator)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `js::UnaryExpression`
[INFO] [stdout]     --> src/generated/ast_builder.rs:8291:13
[INFO] [stdout]      |
[INFO] [stdout] 8291 |             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8291 -             self.unary_expression(span, argument, operator).into(),
[INFO] [stdout] 8291 +             self.unary_expression(span, argument, operator),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[WARN] too many lines in the log, truncating it
