[INFO] cloning repository https://github.com/oeb25/smtlib-rs
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/oeb25/smtlib-rs" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Foeb25%2Fsmtlib-rs", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Foeb25%2Fsmtlib-rs'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 37e7ce4debfb42b968d86141aa0786385bfbd5bf
[INFO] checking oeb25/smtlib-rs against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Foeb25%2Fsmtlib-rs" "/workspace/builds/worker-6-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-6-tc2/source'...
[INFO] [stderr] done.
[INFO] removed /workspace/builds/worker-6-tc2/source/.cargo/config.toml
[INFO] started tweaking git repo https://github.com/oeb25/smtlib-rs
[INFO] finished tweaking git repo https://github.com/oeb25/smtlib-rs
[INFO] tweaked toml for git repo https://github.com/oeb25/smtlib-rs written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/oeb25/smtlib-rs 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 git repo https://github.com/oeb25/smtlib-rs 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] [stderr] warning: unused field `rust-version` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:37:1
[INFO] [stderr]    |
[INFO] [stderr] 37 | rust-version = "1.95.0"
[INFO] [stderr]    | ^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_workspace_package_fields` is set to `warn` by default
[INFO] [stderr] help: consider removing the field `workspace.package.rust-version`
[INFO] [stderr] warning: workspace (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-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] b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e
[INFO] running `Command { std: "docker" "start" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e", 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" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e", 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" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: unused field `rust-version` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:37:1
[INFO] [stderr]    |
[INFO] [stderr] 37 | rust-version = "1.95.0"
[INFO] [stderr]    | ^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_workspace_package_fields` is set to `warn` by default
[INFO] [stderr] help: consider removing the field `workspace.package.rust-version`
[INFO] [stderr] warning: workspace (manifest) generated 1 warning
[INFO] [stderr]    Compiling unicode-ident v1.0.26
[INFO] [stderr]     Checking cfg-if v1.0.5
[INFO] [stderr]     Checking stable_deref_trait v1.2.1
[INFO] [stderr]     Checking writeable v0.6.4
[INFO] [stderr]     Checking smallvec v1.16.2
[INFO] [stderr]    Compiling object v0.37.3
[INFO] [stderr]     Checking gimli v0.32.3
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]     Checking rustc-demangle v0.1.28
[INFO] [stderr]    Compiling icu_locale_fallback_data v2.3.0
[INFO] [stderr]    Compiling rustix v1.1.5
[INFO] [stderr]     Checking litemap v0.8.3
[INFO] [stderr]    Compiling icu_segmenter_data v2.3.0
[INFO] [stderr]     Checking owo-colors v4.4.0
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]    Compiling regex-automata v0.4.18
[INFO] [stderr]     Checking mio v1.2.3
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]     Checking either v1.18.0
[INFO] [stderr]    Compiling typeid v1.0.3
[INFO] [stderr]    Compiling syn v3.0.6
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking itertools v0.15.0
[INFO] [stderr]     Checking is_ci v1.2.0
[INFO] [stderr]     Checking supports-color v3.0.2
[INFO] [stderr]     Checking supports-unicode v3.0.0
[INFO] [stderr]     Checking supports-hyperlinks v3.2.0
[INFO] [stderr]     Checking futures-sink v0.3.34
[INFO] [stderr]     Checking futures-channel v0.3.34
[INFO] [stderr]     Checking indexmap v2.14.2
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking addr2line v0.25.1
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]     Checking futures-io v0.3.34
[INFO] [stderr]     Checking console v0.16.6
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]    Compiling eyre v0.6.14
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking terminal_size v0.4.4
[INFO] [stderr]     Checking tempfile v3.27.0
[INFO] [stderr]    Compiling color-spantrace v0.3.0
[INFO] [stderr]     Checking indenter v0.3.4
[INFO] [stderr]    Compiling prettyplease v0.3.0
[INFO] [stderr]     Checking winnow v1.0.4
[INFO] [stderr]     Checking serde_spanned v1.1.1
[INFO] [stderr]     Checking toml_datetime v1.1.1+spec-1.1.0
[INFO] [stderr]     Checking toml_parser v1.1.3+spec-1.1.0
[INFO] [stderr]    Compiling xshell-macros v0.2.7
[INFO] [stderr]     Checking tracing-error v0.2.1
[INFO] [stderr]     Checking toml_writer v1.1.2+spec-1.1.0
[INFO] [stderr]    Compiling xflags-macros v0.3.2
[INFO] [stderr]     Checking xshell v0.2.7
[INFO] [stderr]     Checking backtrace v0.3.76
[INFO] [stderr]     Checking toml v1.1.6+spec-1.1.0
[INFO] [stderr]     Checking heck v0.5.0
[INFO] [stderr]    Compiling logos-codegen v0.16.1
[INFO] [stderr]     Checking backtrace-ext v0.2.1
[INFO] [stderr]     Checking xflags v0.3.2
[INFO] [stderr]     Checking color-eyre v0.6.5
[INFO] [stderr]    Compiling miette-derive v7.6.0
[INFO] [stderr]    Compiling synstructure v0.14.0
[INFO] [stderr]    Compiling logos-derive v0.16.1
[INFO] [stderr]    Compiling zerofrom-derive v0.1.8
[INFO] [stderr]    Compiling yoke-derive v0.8.3
[INFO] [stderr]    Compiling zerovec-derive v0.11.6
[INFO] [stderr]    Compiling displaydoc v0.2.7
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling tokio-macros v2.7.2
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]     Checking logos v0.16.1
[INFO] [stderr]    Compiling futures-macro v0.3.34
[INFO] [stderr]     Checking zerotrie v0.2.5
[INFO] [stderr]     Checking tokio v1.53.1
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking zerofrom v0.1.8
[INFO] [stderr]     Checking thiserror v2.0.21
[INFO] [stderr]     Checking yoke v0.8.3
[INFO] [stderr]     Checking zerovec v0.11.8
[INFO] [stderr]     Checking tinystr v0.8.4
[INFO] [stderr]     Checking potential_utf v0.1.6
[INFO] [stderr]     Checking icu_collections v2.3.0
[INFO] [stderr]     Checking icu_locale_core v2.3.0
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking ron v0.12.2
[INFO] [stderr]     Checking xtask v0.4.0 (/opt/rustwide/workdir/xtask)
[INFO] [stderr]     Checking icu_provider v2.3.1
[INFO] [stderr]     Checking icu_locale_fallback v2.3.0
[INFO] [stderr]     Checking icu_segmenter v2.3.0
[INFO] [stderr]     Checking futures-executor v0.3.34
[INFO] [stderr]     Checking futures v0.3.34
[INFO] [stderr]     Checking insta v1.48.0
[INFO] [stderr]     Checking textwrap v0.16.4
[INFO] [stderr]     Checking miette v7.6.0
[INFO] [stderr]     Checking tokio-stream v0.1.19
[INFO] [stderr]     Checking smtlib-lowlevel v0.4.0 (/opt/rustwide/workdir/lowlevel)
[INFO] [stderr]     Checking tokio-test v0.4.6
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Keyword<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:42:39
[INFO] [stdout]    |
[INFO] [stdout] 42 |             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout]    |                                       ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 42 -             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout] 42 +             return Ok(Self::WithValue(m0, m1.into()));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout] 42 +             return Ok(Self::WithValue(<lexicon::Keyword<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AttributeValue<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:42:50
[INFO] [stdout]    |
[INFO] [stdout] 42 |             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout]    |                                                  ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout] 42 +             return Ok(Self::WithValue(m0.into(), m1));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -             return Ok(Self::WithValue(m0.into(), m1.into()));
[INFO] [stdout] 42 +             return Ok(Self::WithValue(m0.into(), <AttributeValue<'_> as Into<_>>::into(m1)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Keyword<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:46:74
[INFO] [stdout]    |
[INFO] [stdout] 46 |             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout]    |                                                                          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 46 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 46 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(<lexicon::Keyword<'_> as Into<_>>::into(m0)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SExpr<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:90:71
[INFO] [stdout]    |
[INFO] [stdout] 90 |             #[allow(clippy::useless_conversion)] return Ok(Self::Expr(m0.into()));
[INFO] [stdout]    |                                                                       ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 90 -             #[allow(clippy::useless_conversion)] return Ok(Self::Expr(m0.into()));
[INFO] [stdout] 90 +             #[allow(clippy::useless_conversion)] return Ok(Self::Expr(m0));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 -             #[allow(clippy::useless_conversion)] return Ok(Self::Expr(m0.into()));
[INFO] [stdout] 90 +             #[allow(clippy::useless_conversion)] return Ok(Self::Expr(<SExpr<'_> as Into<_>>::into(m0)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:94:73
[INFO] [stdout]    |
[INFO] [stdout] 94 |             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout]    |                                                                         ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 94 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 94 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 94 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpecConstant<'_>`
[INFO] [stdout]   --> lowlevel/src/ast.rs:99:42
[INFO] [stdout]    |
[INFO] [stdout] 99 |             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout]    |                                          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout] 99 +             return Ok(Self::SpecConstant(m0));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout] 99 +             return Ok(Self::SpecConstant(<SpecConstant<'_> as Into<_>>::into(m0)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[FunctionDec<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:396:43
[INFO] [stdout]     |
[INFO] [stdout] 396 |             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout]     |                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 396 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 396 +             return Ok(Self::DefineFunsRec(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 396 +             return Ok(Self::DefineFunsRec(<&[FunctionDec<'_>] as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[&Term<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:396:54
[INFO] [stdout]     |
[INFO] [stdout] 396 |             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 396 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 396 +             return Ok(Self::DefineFunsRec(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 396 +             return Ok(Self::DefineFunsRec(m0.into(), <&[&Term<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[SortDec<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:412:46
[INFO] [stdout]     |
[INFO] [stdout] 412 |             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout]     |                                              ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout] 412 +             return Ok(Self::DeclareDatatypes(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout] 412 +             return Ok(Self::DeclareDatatypes(<&[SortDec<'_>] as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[DatatypeDec<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:412:57
[INFO] [stdout]     |
[INFO] [stdout] 412 |             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout]     |                                                         ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout] 412 +             return Ok(Self::DeclareDatatypes(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -             return Ok(Self::DeclareDatatypes(m0.into(), m1.into()));
[INFO] [stdout] 412 +             return Ok(Self::DeclareDatatypes(m0.into(), <&[DatatypeDec<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[&Term<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:424:75
[INFO] [stdout]     |
[INFO] [stdout] 424 |             #[allow(clippy::useless_conversion)] return Ok(Self::GetValue(m0.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 424 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetValue(m0.into()));
[INFO] [stdout] 424 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetValue(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetValue(m0.into()));
[INFO] [stdout] 424 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetValue(<&[&Term<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:438:40
[INFO] [stdout]     |
[INFO] [stdout] 438 |             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                        ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(m0, m1.into(), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into(), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[lexicon::Symbol<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:438:51
[INFO] [stdout]     |
[INFO] [stdout] 438 |             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(m0.into(), m1, m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(m0.into(), <&[lexicon::Symbol<'_>] as Into<_>>::into(m1), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:438:62
[INFO] [stdout]     |
[INFO] [stdout] 438 |             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                                              ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(m0.into(), m1.into(), m2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 438 -             return Ok(Self::DefineSort(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 438 +             return Ok(Self::DefineSort(m0.into(), m1.into(), <Sort<'_> as Into<_>>::into(m2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:452:40
[INFO] [stdout]     |
[INFO] [stdout] 452 |             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                        ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(m0, m1.into(), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into(), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Sort<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:452:51
[INFO] [stdout]     |
[INFO] [stdout] 452 |             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(m0.into(), m1, m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(m0.into(), <&[Sort<'_>] as Into<_>>::into(m1), m2.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:452:62
[INFO] [stdout]     |
[INFO] [stdout] 452 |             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]     |                                                              ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 452 -             return Ok(Self::DeclareFun(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 452 +             return Ok(Self::DeclareFun(m0.into(), m1.into(), <Sort<'_> as Into<_>>::into(m2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[PropLiteral<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:465:46
[INFO] [stdout]     |
[INFO] [stdout] 465 |             return Ok(Self::CheckSatAssuming(m0.into()));
[INFO] [stdout]     |                                              ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 465 -             return Ok(Self::CheckSatAssuming(m0.into()));
[INFO] [stdout] 465 +             return Ok(Self::CheckSatAssuming(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 465 -             return Ok(Self::CheckSatAssuming(m0.into()));
[INFO] [stdout] 465 +             return Ok(Self::CheckSatAssuming(<&[PropLiteral<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:474:75
[INFO] [stdout]     |
[INFO] [stdout] 474 |             #[allow(clippy::useless_conversion)] return Ok(Self::Simplify(m0.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 474 -             #[allow(clippy::useless_conversion)] return Ok(Self::Simplify(m0.into()));
[INFO] [stdout] 474 +             #[allow(clippy::useless_conversion)] return Ok(Self::Simplify(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 474 -             #[allow(clippy::useless_conversion)] return Ok(Self::Simplify(m0.into()));
[INFO] [stdout] 474 +             #[allow(clippy::useless_conversion)] return Ok(Self::Simplify(<&Term<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ast::Option<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:483:76
[INFO] [stdout]     |
[INFO] [stdout] 483 |             #[allow(clippy::useless_conversion)] return Ok(Self::SetOption(m0.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 483 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetOption(m0.into()));
[INFO] [stdout] 483 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetOption(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 483 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetOption(m0.into()));
[INFO] [stdout] 483 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetOption(<ast::Option<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:492:75
[INFO] [stdout]     |
[INFO] [stdout] 492 |             #[allow(clippy::useless_conversion)] return Ok(Self::SetLogic(m0.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetLogic(m0.into()));
[INFO] [stdout] 492 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetLogic(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetLogic(m0.into()));
[INFO] [stdout] 492 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetLogic(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:501:74
[INFO] [stdout]     |
[INFO] [stdout] 501 |             #[allow(clippy::useless_conversion)] return Ok(Self::SetInfo(m0.into()));
[INFO] [stdout]     |                                                                          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 501 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetInfo(m0.into()));
[INFO] [stdout] 501 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetInfo(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 -             #[allow(clippy::useless_conversion)] return Ok(Self::SetInfo(m0.into()));
[INFO] [stdout] 501 +             #[allow(clippy::useless_conversion)] return Ok(Self::SetInfo(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:528:71
[INFO] [stdout]     |
[INFO] [stdout] 528 |             #[allow(clippy::useless_conversion)] return Ok(Self::Push(m0.into()));
[INFO] [stdout]     |                                                                       ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 528 -             #[allow(clippy::useless_conversion)] return Ok(Self::Push(m0.into()));
[INFO] [stdout] 528 +             #[allow(clippy::useless_conversion)] return Ok(Self::Push(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 -             #[allow(clippy::useless_conversion)] return Ok(Self::Push(m0.into()));
[INFO] [stdout] 528 +             #[allow(clippy::useless_conversion)] return Ok(Self::Push(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:537:70
[INFO] [stdout]     |
[INFO] [stdout] 537 |             #[allow(clippy::useless_conversion)] return Ok(Self::Pop(m0.into()));
[INFO] [stdout]     |                                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 537 -             #[allow(clippy::useless_conversion)] return Ok(Self::Pop(m0.into()));
[INFO] [stdout] 537 +             #[allow(clippy::useless_conversion)] return Ok(Self::Pop(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 537 -             #[allow(clippy::useless_conversion)] return Ok(Self::Pop(m0.into()));
[INFO] [stdout] 537 +             #[allow(clippy::useless_conversion)] return Ok(Self::Pop(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:546:75
[INFO] [stdout]     |
[INFO] [stdout] 546 |             #[allow(clippy::useless_conversion)] return Ok(Self::Minimize(m0.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 546 -             #[allow(clippy::useless_conversion)] return Ok(Self::Minimize(m0.into()));
[INFO] [stdout] 546 +             #[allow(clippy::useless_conversion)] return Ok(Self::Minimize(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 546 -             #[allow(clippy::useless_conversion)] return Ok(Self::Minimize(m0.into()));
[INFO] [stdout] 546 +             #[allow(clippy::useless_conversion)] return Ok(Self::Minimize(<&Term<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:555:75
[INFO] [stdout]     |
[INFO] [stdout] 555 |             #[allow(clippy::useless_conversion)] return Ok(Self::Maximize(m0.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -             #[allow(clippy::useless_conversion)] return Ok(Self::Maximize(m0.into()));
[INFO] [stdout] 555 +             #[allow(clippy::useless_conversion)] return Ok(Self::Maximize(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -             #[allow(clippy::useless_conversion)] return Ok(Self::Maximize(m0.into()));
[INFO] [stdout] 555 +             #[allow(clippy::useless_conversion)] return Ok(Self::Maximize(<&Term<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Keyword<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:591:76
[INFO] [stdout]     |
[INFO] [stdout] 591 |             #[allow(clippy::useless_conversion)] return Ok(Self::GetOption(m0.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 591 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetOption(m0.into()));
[INFO] [stdout] 591 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetOption(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 591 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetOption(m0.into()));
[INFO] [stdout] 591 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetOption(<lexicon::Keyword<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `InfoFlag<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:609:74
[INFO] [stdout]     |
[INFO] [stdout] 609 |             #[allow(clippy::useless_conversion)] return Ok(Self::GetInfo(m0.into()));
[INFO] [stdout]     |                                                                          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 609 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetInfo(m0.into()));
[INFO] [stdout] 609 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetInfo(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 609 -             #[allow(clippy::useless_conversion)] return Ok(Self::GetInfo(m0.into()));
[INFO] [stdout] 609 +             #[allow(clippy::useless_conversion)] return Ok(Self::GetInfo(<InfoFlag<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:645:71
[INFO] [stdout]     |
[INFO] [stdout] 645 |             #[allow(clippy::useless_conversion)] return Ok(Self::Eval(m0.into()));
[INFO] [stdout]     |                                                                       ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 645 -             #[allow(clippy::useless_conversion)] return Ok(Self::Eval(m0.into()));
[INFO] [stdout] 645 +             #[allow(clippy::useless_conversion)] return Ok(Self::Eval(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 -             #[allow(clippy::useless_conversion)] return Ok(Self::Eval(m0.into()));
[INFO] [stdout] 645 +             #[allow(clippy::useless_conversion)] return Ok(Self::Eval(<&Term<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> lowlevel/src/ast.rs:654:71
[INFO] [stdout]     |
[INFO] [stdout] 654 |             #[allow(clippy::useless_conversion)] return Ok(Self::Echo(m0.into()));
[INFO] [stdout]     |                                                                       ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 654 -             #[allow(clippy::useless_conversion)] return Ok(Self::Echo(m0.into()));
[INFO] [stdout] 654 +             #[allow(clippy::useless_conversion)] return Ok(Self::Echo(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 -             #[allow(clippy::useless_conversion)] return Ok(Self::Echo(m0.into()));
[INFO] [stdout] 654 +             #[allow(clippy::useless_conversion)] return Ok(Self::Echo(<&str as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `FunctionDef<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:664:42
[INFO] [stdout]     |
[INFO] [stdout] 664 |             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout]     |                                          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 664 -             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout] 664 +             return Ok(Self::DefineFunRec(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 664 -             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout] 664 +             return Ok(Self::DefineFunRec(<FunctionDef<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `FunctionDef<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:673:76
[INFO] [stdout]     |
[INFO] [stdout] 673 |             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 673 -             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout] 673 +             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 673 -             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout] 673 +             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(<FunctionDef<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:684:41
[INFO] [stdout]     |
[INFO] [stdout] 684 |             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout]     |                                         ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 684 -             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout] 684 +             return Ok(Self::DeclareSort(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 -             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout] 684 +             return Ok(Self::DeclareSort(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:684:52
[INFO] [stdout]     |
[INFO] [stdout] 684 |             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 684 -             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout] 684 +             return Ok(Self::DeclareSort(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 -             return Ok(Self::DeclareSort(m0.into(), m1.into()));
[INFO] [stdout] 684 +             return Ok(Self::DeclareSort(m0.into(), <lexicon::Numeral<'_> as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:695:45
[INFO] [stdout]     |
[INFO] [stdout] 695 |             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout]     |                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 695 -             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout] 695 +             return Ok(Self::DeclareDatatype(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 -             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout] 695 +             return Ok(Self::DeclareDatatype(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `DatatypeDec<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:695:56
[INFO] [stdout]     |
[INFO] [stdout] 695 |             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout]     |                                                        ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 695 -             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout] 695 +             return Ok(Self::DeclareDatatype(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 -             return Ok(Self::DeclareDatatype(m0.into(), m1.into()));
[INFO] [stdout] 695 +             return Ok(Self::DeclareDatatype(m0.into(), <DatatypeDec<'_> as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:706:42
[INFO] [stdout]     |
[INFO] [stdout] 706 |             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout]     |                                          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 706 -             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout] 706 +             return Ok(Self::DeclareConst(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 706 -             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout] 706 +             return Ok(Self::DeclareConst(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:706:53
[INFO] [stdout]     |
[INFO] [stdout] 706 |             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout]     |                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 706 -             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout] 706 +             return Ok(Self::DeclareConst(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 706 -             return Ok(Self::DeclareConst(m0.into(), m1.into()));
[INFO] [stdout] 706 +             return Ok(Self::DeclareConst(m0.into(), <Sort<'_> as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:726:40
[INFO] [stdout]     |
[INFO] [stdout] 726 |             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout]     |                                        ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 726 -             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout] 726 +             return Ok(Self::AssertSoft(m0, m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 -             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout] 726 +             return Ok(Self::AssertSoft(<&Term<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[OptimizationAttribute<'_>]`
[INFO] [stdout]    --> lowlevel/src/ast.rs:726:51
[INFO] [stdout]     |
[INFO] [stdout] 726 |             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout]     |                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 726 -             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout] 726 +             return Ok(Self::AssertSoft(m0.into(), m1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 -             return Ok(Self::AssertSoft(m0.into(), m1.into()));
[INFO] [stdout] 726 +             return Ok(Self::AssertSoft(m0.into(), <&[OptimizationAttribute<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]    --> lowlevel/src/ast.rs:735:73
[INFO] [stdout]     |
[INFO] [stdout] 735 |             #[allow(clippy::useless_conversion)] return Ok(Self::Assert(m0.into()));
[INFO] [stdout]     |                                                                         ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 735 -             #[allow(clippy::useless_conversion)] return Ok(Self::Assert(m0.into()));
[INFO] [stdout] 735 +             #[allow(clippy::useless_conversion)] return Ok(Self::Assert(m0));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 735 -             #[allow(clippy::useless_conversion)] return Ok(Self::Assert(m0.into()));
[INFO] [stdout] 735 +             #[allow(clippy::useless_conversion)] return Ok(Self::Assert(<&Term<'_> as Into<_>>::into(m0)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[lexicon::Symbol<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1066:33
[INFO] [stdout]      |
[INFO] [stdout] 1066 |             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout]      |                                 ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1066 -             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout] 1066 +             return Ok(Self::Par(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1066 -             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout] 1066 +             return Ok(Self::Par(<&[lexicon::Symbol<'_>] as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[ConstructorDec<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1066:44
[INFO] [stdout]      |
[INFO] [stdout] 1066 |             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout]      |                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1066 -             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout] 1066 +             return Ok(Self::Par(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1066 -             return Ok(Self::Par(m0.into(), m1.into()));
[INFO] [stdout] 1066 +             return Ok(Self::Par(m0.into(), <&[ConstructorDec<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[ConstructorDec<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1072:78
[INFO] [stdout]      |
[INFO] [stdout] 1072 |             #[allow(clippy::useless_conversion)] return Ok(Self::DatatypeDec(m0.into()));
[INFO] [stdout]      |                                                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1072 -             #[allow(clippy::useless_conversion)] return Ok(Self::DatatypeDec(m0.into()));
[INFO] [stdout] 1072 +             #[allow(clippy::useless_conversion)] return Ok(Self::DatatypeDec(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1072 -             #[allow(clippy::useless_conversion)] return Ok(Self::DatatypeDec(m0.into()));
[INFO] [stdout] 1072 +             #[allow(clippy::useless_conversion)] return Ok(Self::DatatypeDec(<&[ConstructorDec<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpecConstant<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1210:42
[INFO] [stdout]      |
[INFO] [stdout] 1210 |             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(m0, m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(<SpecConstant<'_> as Into<_>>::into(m0), m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1210:53
[INFO] [stdout]      |
[INFO] [stdout] 1210 |             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(m0.into(), m1, m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(m0.into(), <Sort<'_> as Into<_>>::into(m1), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Attribute<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1210:64
[INFO] [stdout]      |
[INFO] [stdout] 1210 |             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                                ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1210 -             return Ok(Self::SpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1210 +             return Ok(Self::SpecConstant(m0.into(), m1.into(), <&[Attribute<'_>] as Into<_>>::into(m2)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MetaSpecConstant`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1219:46
[INFO] [stdout]      |
[INFO] [stdout] 1219 |             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(m0, m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(<MetaSpecConstant as Into<_>>::into(m0), m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1219:57
[INFO] [stdout]      |
[INFO] [stdout] 1219 |             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(m0.into(), m1, m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(m0.into(), <Sort<'_> as Into<_>>::into(m1), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Attribute<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1219:68
[INFO] [stdout]      |
[INFO] [stdout] 1219 |             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1219 -             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1219 +             return Ok(Self::MetaSpecConstant(m0.into(), m1.into(), <&[Attribute<'_>] as Into<_>>::into(m2)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1228:40
[INFO] [stdout]      |
[INFO] [stdout] 1228 |             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(m0, m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(<Identifier<'_> as Into<_>>::into(m0), m1.into(), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Sort<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1228:51
[INFO] [stdout]      |
[INFO] [stdout] 1228 |             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(m0.into(), m1, m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(m0.into(), <&[Sort<'_>] as Into<_>>::into(m1), m2.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Attribute<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1228:62
[INFO] [stdout]      |
[INFO] [stdout] 1228 |             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout]      |                                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(m0.into(), m1.into(), m2));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1228 -             return Ok(Self::Identifier(m0.into(), m1.into(), m2.into()));
[INFO] [stdout] 1228 +             return Ok(Self::Identifier(m0.into(), m1.into(), <&[Attribute<'_>] as Into<_>>::into(m2)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1345:72
[INFO] [stdout]      |
[INFO] [stdout] 1345 |             #[allow(clippy::useless_conversion)] return Ok(Self::Error(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1345 -             #[allow(clippy::useless_conversion)] return Ok(Self::Error(m0.into()));
[INFO] [stdout] 1345 +             #[allow(clippy::useless_conversion)] return Ok(Self::Error(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1345 -             #[allow(clippy::useless_conversion)] return Ok(Self::Error(m0.into()));
[INFO] [stdout] 1345 +             #[allow(clippy::useless_conversion)] return Ok(Self::Error(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpecificSuccessResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1358:53
[INFO] [stdout]      |
[INFO] [stdout] 1358 |             return Ok(Self::SpecificSuccessResponse(m0.into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1358 -             return Ok(Self::SpecificSuccessResponse(m0.into()));
[INFO] [stdout] 1358 +             return Ok(Self::SpecificSuccessResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1358 -             return Ok(Self::SpecificSuccessResponse(m0.into()));
[INFO] [stdout] 1358 +             return Ok(Self::SpecificSuccessResponse(<SpecificSuccessResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1665:37
[INFO] [stdout]      |
[INFO] [stdout] 1665 |             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout]      |                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1665 -             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout] 1665 +             return Ok(Self::Indexed(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1665 -             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout] 1665 +             return Ok(Self::Indexed(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[ast::Index<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1665:48
[INFO] [stdout]      |
[INFO] [stdout] 1665 |             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout]      |                                                ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1665 -             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout] 1665 +             return Ok(Self::Indexed(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1665 -             return Ok(Self::Indexed(m0.into(), m1.into()));
[INFO] [stdout] 1665 +             return Ok(Self::Indexed(m0.into(), <&[ast::Index<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1669:73
[INFO] [stdout]      |
[INFO] [stdout] 1669 |             #[allow(clippy::useless_conversion)] return Ok(Self::Simple(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1669 -             #[allow(clippy::useless_conversion)] return Ok(Self::Simple(m0.into()));
[INFO] [stdout] 1669 +             #[allow(clippy::useless_conversion)] return Ok(Self::Simple(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1669 -             #[allow(clippy::useless_conversion)] return Ok(Self::Simple(m0.into()));
[INFO] [stdout] 1669 +             #[allow(clippy::useless_conversion)] return Ok(Self::Simple(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1704:73
[INFO] [stdout]      |
[INFO] [stdout] 1704 |             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1704 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 1704 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1704 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 1704 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1708:74
[INFO] [stdout]      |
[INFO] [stdout] 1708 |             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1708 -             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout] 1708 +             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1708 -             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout] 1708 +             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Keyword<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1796:74
[INFO] [stdout]      |
[INFO] [stdout] 1796 |             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1796 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 1796 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1796 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 1796 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(<lexicon::Keyword<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1853:74
[INFO] [stdout]      |
[INFO] [stdout] 1853 |             #[allow(clippy::useless_conversion)] return Ok(Self::Version(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1853 -             #[allow(clippy::useless_conversion)] return Ok(Self::Version(m0.into()));
[INFO] [stdout] 1853 +             #[allow(clippy::useless_conversion)] return Ok(Self::Version(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1853 -             #[allow(clippy::useless_conversion)] return Ok(Self::Version(m0.into()));
[INFO] [stdout] 1853 +             #[allow(clippy::useless_conversion)] return Ok(Self::Version(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ReasonUnknown<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1859:43
[INFO] [stdout]      |
[INFO] [stdout] 1859 |             return Ok(Self::ReasonUnknown(m0.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1859 -             return Ok(Self::ReasonUnknown(m0.into()));
[INFO] [stdout] 1859 +             return Ok(Self::ReasonUnknown(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1859 -             return Ok(Self::ReasonUnknown(m0.into()));
[INFO] [stdout] 1859 +             return Ok(Self::ReasonUnknown(<ReasonUnknown<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1864:71
[INFO] [stdout]      |
[INFO] [stdout] 1864 |             #[allow(clippy::useless_conversion)] return Ok(Self::Name(m0.into()));
[INFO] [stdout]      |                                                                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1864 -             #[allow(clippy::useless_conversion)] return Ok(Self::Name(m0.into()));
[INFO] [stdout] 1864 +             #[allow(clippy::useless_conversion)] return Ok(Self::Name(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1864 -             #[allow(clippy::useless_conversion)] return Ok(Self::Name(m0.into()));
[INFO] [stdout] 1864 +             #[allow(clippy::useless_conversion)] return Ok(Self::Name(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ErrorBehavior`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1870:43
[INFO] [stdout]      |
[INFO] [stdout] 1870 |             return Ok(Self::ErrorBehavior(m0.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1870 -             return Ok(Self::ErrorBehavior(m0.into()));
[INFO] [stdout] 1870 +             return Ok(Self::ErrorBehavior(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1870 -             return Ok(Self::ErrorBehavior(m0.into()));
[INFO] [stdout] 1870 +             return Ok(Self::ErrorBehavior(<ErrorBehavior as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1875:74
[INFO] [stdout]      |
[INFO] [stdout] 1875 |             #[allow(clippy::useless_conversion)] return Ok(Self::Authors(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1875 -             #[allow(clippy::useless_conversion)] return Ok(Self::Authors(m0.into()));
[INFO] [stdout] 1875 +             #[allow(clippy::useless_conversion)] return Ok(Self::Authors(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1875 -             #[allow(clippy::useless_conversion)] return Ok(Self::Authors(m0.into()));
[INFO] [stdout] 1875 +             #[allow(clippy::useless_conversion)] return Ok(Self::Authors(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1881:50
[INFO] [stdout]      |
[INFO] [stdout] 1881 |             return Ok(Self::AssertionStackLevels(m0.into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1881 -             return Ok(Self::AssertionStackLevels(m0.into()));
[INFO] [stdout] 1881 +             return Ok(Self::AssertionStackLevels(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1881 -             return Ok(Self::AssertionStackLevels(m0.into()));
[INFO] [stdout] 1881 +             return Ok(Self::AssertionStackLevels(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1885:76
[INFO] [stdout]      |
[INFO] [stdout] 1885 |             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1885 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 1885 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1885 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 1885 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[lexicon::Symbol<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1975:75
[INFO] [stdout]      |
[INFO] [stdout] 1975 |             #[allow(clippy::useless_conversion)] return Ok(Self::Theories(m0.into()));
[INFO] [stdout]      |                                                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1975 -             #[allow(clippy::useless_conversion)] return Ok(Self::Theories(m0.into()));
[INFO] [stdout] 1975 +             #[allow(clippy::useless_conversion)] return Ok(Self::Theories(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1975 -             #[allow(clippy::useless_conversion)] return Ok(Self::Theories(m0.into()));
[INFO] [stdout] 1975 +             #[allow(clippy::useless_conversion)] return Ok(Self::Theories(<&[lexicon::Symbol<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1980:73
[INFO] [stdout]      |
[INFO] [stdout] 1980 |             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1980 -             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout] 1980 +             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1980 -             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout] 1980 +             #[allow(clippy::useless_conversion)] return Ok(Self::Values(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1985:72
[INFO] [stdout]      |
[INFO] [stdout] 1985 |             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1985 -             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout] 1985 +             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1985 -             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout] 1985 +             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1990:75
[INFO] [stdout]      |
[INFO] [stdout] 1990 |             #[allow(clippy::useless_conversion)] return Ok(Self::Language(m0.into()));
[INFO] [stdout]      |                                                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1990 -             #[allow(clippy::useless_conversion)] return Ok(Self::Language(m0.into()));
[INFO] [stdout] 1990 +             #[allow(clippy::useless_conversion)] return Ok(Self::Language(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1990 -             #[allow(clippy::useless_conversion)] return Ok(Self::Language(m0.into()));
[INFO] [stdout] 1990 +             #[allow(clippy::useless_conversion)] return Ok(Self::Language(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1995:77
[INFO] [stdout]      |
[INFO] [stdout] 1995 |             #[allow(clippy::useless_conversion)] return Ok(Self::Extensions(m0.into()));
[INFO] [stdout]      |                                                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1995 -             #[allow(clippy::useless_conversion)] return Ok(Self::Extensions(m0.into()));
[INFO] [stdout] 1995 +             #[allow(clippy::useless_conversion)] return Ok(Self::Extensions(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1995 -             #[allow(clippy::useless_conversion)] return Ok(Self::Extensions(m0.into()));
[INFO] [stdout] 1995 +             #[allow(clippy::useless_conversion)] return Ok(Self::Extensions(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:1999:76
[INFO] [stdout]      |
[INFO] [stdout] 1999 |             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1999 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 1999 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1999 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 1999 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[FunctionDec<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2135:43
[INFO] [stdout]      |
[INFO] [stdout] 2135 |             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2135 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 2135 +             return Ok(Self::DefineFunsRec(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2135 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 2135 +             return Ok(Self::DefineFunsRec(<&[FunctionDec<'_>] as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[&Term<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2135:54
[INFO] [stdout]      |
[INFO] [stdout] 2135 |             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout]      |                                                      ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2135 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 2135 +             return Ok(Self::DefineFunsRec(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2135 -             return Ok(Self::DefineFunsRec(m0.into(), m1.into()));
[INFO] [stdout] 2135 +             return Ok(Self::DefineFunsRec(m0.into(), <&[&Term<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `FunctionDef<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2145:42
[INFO] [stdout]      |
[INFO] [stdout] 2145 |             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2145 -             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout] 2145 +             return Ok(Self::DefineFunRec(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2145 -             return Ok(Self::DefineFunRec(m0.into()));
[INFO] [stdout] 2145 +             return Ok(Self::DefineFunRec(<FunctionDef<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `FunctionDef<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2154:76
[INFO] [stdout]      |
[INFO] [stdout] 2154 |             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2154 -             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout] 2154 +             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2154 -             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(m0.into()));
[INFO] [stdout] 2154 +             #[allow(clippy::useless_conversion)] return Ok(Self::DefineFun(<FunctionDef<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2200:73
[INFO] [stdout]      |
[INFO] [stdout] 2200 |             #[allow(clippy::useless_conversion)] return Ok(Self::Weight(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             #[allow(clippy::useless_conversion)] return Ok(Self::Weight(m0.into()));
[INFO] [stdout] 2200 +             #[allow(clippy::useless_conversion)] return Ok(Self::Weight(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2200 -             #[allow(clippy::useless_conversion)] return Ok(Self::Weight(m0.into()));
[INFO] [stdout] 2200 +             #[allow(clippy::useless_conversion)] return Ok(Self::Weight(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2205:69
[INFO] [stdout]      |
[INFO] [stdout] 2205 |             #[allow(clippy::useless_conversion)] return Ok(Self::Id(m0.into()));
[INFO] [stdout]      |                                                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2205 -             #[allow(clippy::useless_conversion)] return Ok(Self::Id(m0.into()));
[INFO] [stdout] 2205 +             #[allow(clippy::useless_conversion)] return Ok(Self::Id(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2205 -             #[allow(clippy::useless_conversion)] return Ok(Self::Id(m0.into()));
[INFO] [stdout] 2205 +             #[allow(clippy::useless_conversion)] return Ok(Self::Id(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2209:76
[INFO] [stdout]      |
[INFO] [stdout] 2209 |             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2209 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 2209 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2209 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 2209 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2359:76
[INFO] [stdout]      |
[INFO] [stdout] 2359 |             #[allow(clippy::useless_conversion)] return Ok(Self::Verbosity(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2359 -             #[allow(clippy::useless_conversion)] return Ok(Self::Verbosity(m0.into()));
[INFO] [stdout] 2359 +             #[allow(clippy::useless_conversion)] return Ok(Self::Verbosity(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2359 -             #[allow(clippy::useless_conversion)] return Ok(Self::Verbosity(m0.into()));
[INFO] [stdout] 2359 +             #[allow(clippy::useless_conversion)] return Ok(Self::Verbosity(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2365:55
[INFO] [stdout]      |
[INFO] [stdout] 2365 |             return Ok(Self::ReproducibleResourceLimit(m0.into()));
[INFO] [stdout]      |                                                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2365 -             return Ok(Self::ReproducibleResourceLimit(m0.into()));
[INFO] [stdout] 2365 +             return Ok(Self::ReproducibleResourceLimit(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2365 -             return Ok(Self::ReproducibleResourceLimit(m0.into()));
[INFO] [stdout] 2365 +             return Ok(Self::ReproducibleResourceLimit(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2371:50
[INFO] [stdout]      |
[INFO] [stdout] 2371 |             return Ok(Self::RegularOutputChannel(m0.into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2371 -             return Ok(Self::RegularOutputChannel(m0.into()));
[INFO] [stdout] 2371 +             return Ok(Self::RegularOutputChannel(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2371 -             return Ok(Self::RegularOutputChannel(m0.into()));
[INFO] [stdout] 2371 +             return Ok(Self::RegularOutputChannel(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2376:77
[INFO] [stdout]      |
[INFO] [stdout] 2376 |             #[allow(clippy::useless_conversion)] return Ok(Self::RandomSeed(m0.into()));
[INFO] [stdout]      |                                                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2376 -             #[allow(clippy::useless_conversion)] return Ok(Self::RandomSeed(m0.into()));
[INFO] [stdout] 2376 +             #[allow(clippy::useless_conversion)] return Ok(Self::RandomSeed(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2376 -             #[allow(clippy::useless_conversion)] return Ok(Self::RandomSeed(m0.into()));
[INFO] [stdout] 2376 +             #[allow(clippy::useless_conversion)] return Ok(Self::RandomSeed(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2382:47
[INFO] [stdout]      |
[INFO] [stdout] 2382 |             return Ok(Self::ProduceUnsatCores(m0.into()));
[INFO] [stdout]      |                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2382 -             return Ok(Self::ProduceUnsatCores(m0.into()));
[INFO] [stdout] 2382 +             return Ok(Self::ProduceUnsatCores(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2382 -             return Ok(Self::ProduceUnsatCores(m0.into()));
[INFO] [stdout] 2382 +             return Ok(Self::ProduceUnsatCores(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2388:53
[INFO] [stdout]      |
[INFO] [stdout] 2388 |             return Ok(Self::ProduceUnsatAssumptions(m0.into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2388 -             return Ok(Self::ProduceUnsatAssumptions(m0.into()));
[INFO] [stdout] 2388 +             return Ok(Self::ProduceUnsatAssumptions(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2388 -             return Ok(Self::ProduceUnsatAssumptions(m0.into()));
[INFO] [stdout] 2388 +             return Ok(Self::ProduceUnsatAssumptions(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2394:43
[INFO] [stdout]      |
[INFO] [stdout] 2394 |             return Ok(Self::ProduceProofs(m0.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2394 -             return Ok(Self::ProduceProofs(m0.into()));
[INFO] [stdout] 2394 +             return Ok(Self::ProduceProofs(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2394 -             return Ok(Self::ProduceProofs(m0.into()));
[INFO] [stdout] 2394 +             return Ok(Self::ProduceProofs(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2400:43
[INFO] [stdout]      |
[INFO] [stdout] 2400 |             return Ok(Self::ProduceModels(m0.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2400 -             return Ok(Self::ProduceModels(m0.into()));
[INFO] [stdout] 2400 +             return Ok(Self::ProduceModels(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2400 -             return Ok(Self::ProduceModels(m0.into()));
[INFO] [stdout] 2400 +             return Ok(Self::ProduceModels(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2406:48
[INFO] [stdout]      |
[INFO] [stdout] 2406 |             return Ok(Self::ProduceAssignments(m0.into()));
[INFO] [stdout]      |                                                ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2406 -             return Ok(Self::ProduceAssignments(m0.into()));
[INFO] [stdout] 2406 +             return Ok(Self::ProduceAssignments(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2406 -             return Ok(Self::ProduceAssignments(m0.into()));
[INFO] [stdout] 2406 +             return Ok(Self::ProduceAssignments(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2412:47
[INFO] [stdout]      |
[INFO] [stdout] 2412 |             return Ok(Self::ProduceAssertions(m0.into()));
[INFO] [stdout]      |                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2412 -             return Ok(Self::ProduceAssertions(m0.into()));
[INFO] [stdout] 2412 +             return Ok(Self::ProduceAssertions(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2412 -             return Ok(Self::ProduceAssertions(m0.into()));
[INFO] [stdout] 2412 +             return Ok(Self::ProduceAssertions(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2418:42
[INFO] [stdout]      |
[INFO] [stdout] 2418 |             return Ok(Self::PrintSuccess(m0.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2418 -             return Ok(Self::PrintSuccess(m0.into()));
[INFO] [stdout] 2418 +             return Ok(Self::PrintSuccess(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2418 -             return Ok(Self::PrintSuccess(m0.into()));
[INFO] [stdout] 2418 +             return Ok(Self::PrintSuccess(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `OptimizationPriority`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2423:78
[INFO] [stdout]      |
[INFO] [stdout] 2423 |             #[allow(clippy::useless_conversion)] return Ok(Self::OptPriority(m0.into()));
[INFO] [stdout]      |                                                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             #[allow(clippy::useless_conversion)] return Ok(Self::OptPriority(m0.into()));
[INFO] [stdout] 2423 +             #[allow(clippy::useless_conversion)] return Ok(Self::OptPriority(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2423 -             #[allow(clippy::useless_conversion)] return Ok(Self::OptPriority(m0.into()));
[INFO] [stdout] 2423 +             #[allow(clippy::useless_conversion)] return Ok(Self::OptPriority(<OptimizationPriority as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2429:45
[INFO] [stdout]      |
[INFO] [stdout] 2429 |             return Ok(Self::InteractiveMode(m0.into()));
[INFO] [stdout]      |                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2429 -             return Ok(Self::InteractiveMode(m0.into()));
[INFO] [stdout] 2429 +             return Ok(Self::InteractiveMode(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2429 -             return Ok(Self::InteractiveMode(m0.into()));
[INFO] [stdout] 2429 +             return Ok(Self::InteractiveMode(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2435:48
[INFO] [stdout]      |
[INFO] [stdout] 2435 |             return Ok(Self::GlobalDeclarations(m0.into()));
[INFO] [stdout]      |                                                ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2435 -             return Ok(Self::GlobalDeclarations(m0.into()));
[INFO] [stdout] 2435 +             return Ok(Self::GlobalDeclarations(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2435 -             return Ok(Self::GlobalDeclarations(m0.into()));
[INFO] [stdout] 2435 +             return Ok(Self::GlobalDeclarations(<bool as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2441:53
[INFO] [stdout]      |
[INFO] [stdout] 2441 |             return Ok(Self::DiagnosticOutputChannel(m0.into()));
[INFO] [stdout]      |                                                     ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2441 -             return Ok(Self::DiagnosticOutputChannel(m0.into()));
[INFO] [stdout] 2441 +             return Ok(Self::DiagnosticOutputChannel(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2441 -             return Ok(Self::DiagnosticOutputChannel(m0.into()));
[INFO] [stdout] 2441 +             return Ok(Self::DiagnosticOutputChannel(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2445:76
[INFO] [stdout]      |
[INFO] [stdout] 2445 |             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2445 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 2445 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2445 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 2445 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[lexicon::Symbol<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2505:33
[INFO] [stdout]      |
[INFO] [stdout] 2505 |             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |                                 ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0, m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(<&[lexicon::Symbol<'_>] as Into<_>>::into(m0), m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2505:44
[INFO] [stdout]      |
[INFO] [stdout] 2505 |             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), m1, m2.into(), m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), <Identifier<'_> as Into<_>>::into(m1), m2.into(), m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Sort<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2505:55
[INFO] [stdout]      |
[INFO] [stdout] 2505 |             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |                                                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), m1.into(), m2, m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), m1.into(), <&[Sort<'_>] as Into<_>>::into(m2), m3.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Attribute<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2505:66
[INFO] [stdout]      |
[INFO] [stdout] 2505 |             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout]      |                                                                  ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2505 -             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), m3.into()));
[INFO] [stdout] 2505 +             return Ok(Self::Par(m0.into(), m1.into(), m2.into(), <&[Attribute<'_>] as Into<_>>::into(m3)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `FunSymbolDecl<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2510:43
[INFO] [stdout]      |
[INFO] [stdout] 2510 |             return Ok(Self::FunSymbolDecl(m0.into()));
[INFO] [stdout]      |                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2510 -             return Ok(Self::FunSymbolDecl(m0.into()));
[INFO] [stdout] 2510 +             return Ok(Self::FunSymbolDecl(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2510 -             return Ok(Self::FunSymbolDecl(m0.into()));
[INFO] [stdout] 2510 +             return Ok(Self::FunSymbolDecl(<FunSymbolDecl<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2549:41
[INFO] [stdout]      |
[INFO] [stdout] 2549 |             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout]      |                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2549 -             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout] 2549 +             return Ok(Self::Application(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2549 -             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout] 2549 +             return Ok(Self::Application(<lexicon::Symbol<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[lexicon::Symbol<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2549:52
[INFO] [stdout]      |
[INFO] [stdout] 2549 |             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout]      |                                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2549 -             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout] 2549 +             return Ok(Self::Application(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2549 -             return Ok(Self::Application(m0.into(), m1.into()));
[INFO] [stdout] 2549 +             return Ok(Self::Application(m0.into(), <&[lexicon::Symbol<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2553:73
[INFO] [stdout]      |
[INFO] [stdout] 2553 |             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2553 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2553 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2553 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2553 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2595:70
[INFO] [stdout]      |
[INFO] [stdout] 2595 |             #[allow(clippy::useless_conversion)] return Ok(Self::Not(m0.into()));
[INFO] [stdout]      |                                                                      ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2595 -             #[allow(clippy::useless_conversion)] return Ok(Self::Not(m0.into()));
[INFO] [stdout] 2595 +             #[allow(clippy::useless_conversion)] return Ok(Self::Not(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2595 -             #[allow(clippy::useless_conversion)] return Ok(Self::Not(m0.into()));
[INFO] [stdout] 2595 +             #[allow(clippy::useless_conversion)] return Ok(Self::Not(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2599:73
[INFO] [stdout]      |
[INFO] [stdout] 2599 |             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2599 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2599 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2599 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2599 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2646:36
[INFO] [stdout]      |
[INFO] [stdout] 2646 |             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout]      |                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2646 -             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout] 2646 +             return Ok(Self::Sorted(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2646 -             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout] 2646 +             return Ok(Self::Sorted(<Identifier<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Sort<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2646:47
[INFO] [stdout]      |
[INFO] [stdout] 2646 |             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout]      |                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2646 -             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout] 2646 +             return Ok(Self::Sorted(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2646 -             return Ok(Self::Sorted(m0.into(), m1.into()));
[INFO] [stdout] 2646 +             return Ok(Self::Sorted(m0.into(), <Sort<'_> as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2650:77
[INFO] [stdout]      |
[INFO] [stdout] 2650 |             #[allow(clippy::useless_conversion)] return Ok(Self::Identifier(m0.into()));
[INFO] [stdout]      |                                                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2650 -             #[allow(clippy::useless_conversion)] return Ok(Self::Identifier(m0.into()));
[INFO] [stdout] 2650 +             #[allow(clippy::useless_conversion)] return Ok(Self::Identifier(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2650 -             #[allow(clippy::useless_conversion)] return Ok(Self::Identifier(m0.into()));
[INFO] [stdout] 2650 +             #[allow(clippy::useless_conversion)] return Ok(Self::Identifier(<Identifier<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SExpr<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2698:72
[INFO] [stdout]      |
[INFO] [stdout] 2698 |             #[allow(clippy::useless_conversion)] return Ok(Self::SExpr(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2698 -             #[allow(clippy::useless_conversion)] return Ok(Self::SExpr(m0.into()));
[INFO] [stdout] 2698 +             #[allow(clippy::useless_conversion)] return Ok(Self::SExpr(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2698 -             #[allow(clippy::useless_conversion)] return Ok(Self::SExpr(m0.into()));
[INFO] [stdout] 2698 +             #[allow(clippy::useless_conversion)] return Ok(Self::SExpr(<SExpr<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[SExpr<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2746:72
[INFO] [stdout]      |
[INFO] [stdout] 2746 |             #[allow(clippy::useless_conversion)] return Ok(Self::Paren(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2746 -             #[allow(clippy::useless_conversion)] return Ok(Self::Paren(m0.into()));
[INFO] [stdout] 2746 +             #[allow(clippy::useless_conversion)] return Ok(Self::Paren(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2746 -             #[allow(clippy::useless_conversion)] return Ok(Self::Paren(m0.into()));
[INFO] [stdout] 2746 +             #[allow(clippy::useless_conversion)] return Ok(Self::Paren(<&[SExpr<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Symbol<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2750:73
[INFO] [stdout]      |
[INFO] [stdout] 2750 |             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2750 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2750 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2750 -             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(m0.into()));
[INFO] [stdout] 2750 +             #[allow(clippy::useless_conversion)] return Ok(Self::Symbol(<lexicon::Symbol<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpecConstant<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2755:42
[INFO] [stdout]      |
[INFO] [stdout] 2755 |             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout] 2755 +             return Ok(Self::SpecConstant(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2755 -             return Ok(Self::SpecConstant(m0.into()));
[INFO] [stdout] 2755 +             return Ok(Self::SpecConstant(<SpecConstant<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Reserved<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2759:75
[INFO] [stdout]      |
[INFO] [stdout] 2759 |             #[allow(clippy::useless_conversion)] return Ok(Self::Reserved(m0.into()));
[INFO] [stdout]      |                                                                           ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2759 -             #[allow(clippy::useless_conversion)] return Ok(Self::Reserved(m0.into()));
[INFO] [stdout] 2759 +             #[allow(clippy::useless_conversion)] return Ok(Self::Reserved(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2759 -             #[allow(clippy::useless_conversion)] return Ok(Self::Reserved(m0.into()));
[INFO] [stdout] 2759 +             #[allow(clippy::useless_conversion)] return Ok(Self::Reserved(<lexicon::Reserved<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Keyword<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2763:74
[INFO] [stdout]      |
[INFO] [stdout] 2763 |             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2763 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 2763 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2763 -             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(m0.into()));
[INFO] [stdout] 2763 +             #[allow(clippy::useless_conversion)] return Ok(Self::Keyword(<lexicon::Keyword<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2876:71
[INFO] [stdout]      |
[INFO] [stdout] 2876 |             #[allow(clippy::useless_conversion)] return Ok(Self::Sort(m0.into()));
[INFO] [stdout]      |                                                                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2876 -             #[allow(clippy::useless_conversion)] return Ok(Self::Sort(m0.into()));
[INFO] [stdout] 2876 +             #[allow(clippy::useless_conversion)] return Ok(Self::Sort(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2876 -             #[allow(clippy::useless_conversion)] return Ok(Self::Sort(m0.into()));
[INFO] [stdout] 2876 +             #[allow(clippy::useless_conversion)] return Ok(Self::Sort(<Identifier<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Identifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2884:40
[INFO] [stdout]      |
[INFO] [stdout] 2884 |             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout]      |                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout] 2884 +             return Ok(Self::Parametric(m0, m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2884 -             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout] 2884 +             return Ok(Self::Parametric(<Identifier<'_> as Into<_>>::into(m0), m1.into()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Sort<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:2884:51
[INFO] [stdout]      |
[INFO] [stdout] 2884 |             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout]      |                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout] 2884 +             return Ok(Self::Parametric(m0.into(), m1));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2884 -             return Ok(Self::Parametric(m0.into(), m1.into()));
[INFO] [stdout] 2884 +             return Ok(Self::Parametric(m0.into(), <&[Sort<'_>] as Into<_>>::into(m1)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3019:73
[INFO] [stdout]      |
[INFO] [stdout] 3019 |             #[allow(clippy::useless_conversion)] return Ok(Self::String(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             #[allow(clippy::useless_conversion)] return Ok(Self::String(m0.into()));
[INFO] [stdout] 3019 +             #[allow(clippy::useless_conversion)] return Ok(Self::String(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             #[allow(clippy::useless_conversion)] return Ok(Self::String(m0.into()));
[INFO] [stdout] 3019 +             #[allow(clippy::useless_conversion)] return Ok(Self::String(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Numeral<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3023:74
[INFO] [stdout]      |
[INFO] [stdout] 3023 |             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3023 -             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout] 3023 +             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3023 -             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(m0.into()));
[INFO] [stdout] 3023 +             #[allow(clippy::useless_conversion)] return Ok(Self::Numeral(<lexicon::Numeral<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Hexadecimal<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3027:78
[INFO] [stdout]      |
[INFO] [stdout] 3027 |             #[allow(clippy::useless_conversion)] return Ok(Self::Hexadecimal(m0.into()));
[INFO] [stdout]      |                                                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3027 -             #[allow(clippy::useless_conversion)] return Ok(Self::Hexadecimal(m0.into()));
[INFO] [stdout] 3027 +             #[allow(clippy::useless_conversion)] return Ok(Self::Hexadecimal(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3027 -             #[allow(clippy::useless_conversion)] return Ok(Self::Hexadecimal(m0.into()));
[INFO] [stdout] 3027 +             #[allow(clippy::useless_conversion)] return Ok(Self::Hexadecimal(<lexicon::Hexadecimal<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Decimal<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3031:74
[INFO] [stdout]      |
[INFO] [stdout] 3031 |             #[allow(clippy::useless_conversion)] return Ok(Self::Decimal(m0.into()));
[INFO] [stdout]      |                                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3031 -             #[allow(clippy::useless_conversion)] return Ok(Self::Decimal(m0.into()));
[INFO] [stdout] 3031 +             #[allow(clippy::useless_conversion)] return Ok(Self::Decimal(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3031 -             #[allow(clippy::useless_conversion)] return Ok(Self::Decimal(m0.into()));
[INFO] [stdout] 3031 +             #[allow(clippy::useless_conversion)] return Ok(Self::Decimal(<lexicon::Decimal<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `lexicon::Binary<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3035:73
[INFO] [stdout]      |
[INFO] [stdout] 3035 |             #[allow(clippy::useless_conversion)] return Ok(Self::Binary(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3035 -             #[allow(clippy::useless_conversion)] return Ok(Self::Binary(m0.into()));
[INFO] [stdout] 3035 +             #[allow(clippy::useless_conversion)] return Ok(Self::Binary(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3035 -             #[allow(clippy::useless_conversion)] return Ok(Self::Binary(m0.into()));
[INFO] [stdout] 3035 +             #[allow(clippy::useless_conversion)] return Ok(Self::Binary(<lexicon::Binary<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SimplifyResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3121:46
[INFO] [stdout]      |
[INFO] [stdout] 3121 |             return Ok(Self::SimplifyResponse(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3121 -             return Ok(Self::SimplifyResponse(m0.into()));
[INFO] [stdout] 3121 +             return Ok(Self::SimplifyResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3121 -             return Ok(Self::SimplifyResponse(m0.into()));
[INFO] [stdout] 3121 +             return Ok(Self::SimplifyResponse(<SimplifyResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetValueResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3126:46
[INFO] [stdout]      |
[INFO] [stdout] 3126 |             return Ok(Self::GetValueResponse(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3126 -             return Ok(Self::GetValueResponse(m0.into()));
[INFO] [stdout] 3126 +             return Ok(Self::GetValueResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 -             return Ok(Self::GetValueResponse(m0.into()));
[INFO] [stdout] 3126 +             return Ok(Self::GetValueResponse(<GetValueResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetUnsatCoreResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3131:50
[INFO] [stdout]      |
[INFO] [stdout] 3131 |             return Ok(Self::GetUnsatCoreResponse(m0.into()));
[INFO] [stdout]      |                                                  ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3131 -             return Ok(Self::GetUnsatCoreResponse(m0.into()));
[INFO] [stdout] 3131 +             return Ok(Self::GetUnsatCoreResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3131 -             return Ok(Self::GetUnsatCoreResponse(m0.into()));
[INFO] [stdout] 3131 +             return Ok(Self::GetUnsatCoreResponse(<GetUnsatCoreResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetUnsatAssumptionsResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3136:57
[INFO] [stdout]      |
[INFO] [stdout] 3136 |             return Ok(Self::GetUnsatAssumptionsResponse(m0.into()));
[INFO] [stdout]      |                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3136 -             return Ok(Self::GetUnsatAssumptionsResponse(m0.into()));
[INFO] [stdout] 3136 +             return Ok(Self::GetUnsatAssumptionsResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3136 -             return Ok(Self::GetUnsatAssumptionsResponse(m0.into()));
[INFO] [stdout] 3136 +             return Ok(Self::GetUnsatAssumptionsResponse(<GetUnsatAssumptionsResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetProofResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3141:46
[INFO] [stdout]      |
[INFO] [stdout] 3141 |             return Ok(Self::GetProofResponse(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3141 -             return Ok(Self::GetProofResponse(m0.into()));
[INFO] [stdout] 3141 +             return Ok(Self::GetProofResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3141 -             return Ok(Self::GetProofResponse(m0.into()));
[INFO] [stdout] 3141 +             return Ok(Self::GetProofResponse(<GetProofResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetOptionResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3146:47
[INFO] [stdout]      |
[INFO] [stdout] 3146 |             return Ok(Self::GetOptionResponse(m0.into()));
[INFO] [stdout]      |                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::GetOptionResponse(m0.into()));
[INFO] [stdout] 3146 +             return Ok(Self::GetOptionResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3146 -             return Ok(Self::GetOptionResponse(m0.into()));
[INFO] [stdout] 3146 +             return Ok(Self::GetOptionResponse(<GetOptionResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetModelResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3151:46
[INFO] [stdout]      |
[INFO] [stdout] 3151 |             return Ok(Self::GetModelResponse(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3151 -             return Ok(Self::GetModelResponse(m0.into()));
[INFO] [stdout] 3151 +             return Ok(Self::GetModelResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3151 -             return Ok(Self::GetModelResponse(m0.into()));
[INFO] [stdout] 3151 +             return Ok(Self::GetModelResponse(<GetModelResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetInfoResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3156:45
[INFO] [stdout]      |
[INFO] [stdout] 3156 |             return Ok(Self::GetInfoResponse(m0.into()));
[INFO] [stdout]      |                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::GetInfoResponse(m0.into()));
[INFO] [stdout] 3156 +             return Ok(Self::GetInfoResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3156 -             return Ok(Self::GetInfoResponse(m0.into()));
[INFO] [stdout] 3156 +             return Ok(Self::GetInfoResponse(<GetInfoResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetAssignmentResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3161:51
[INFO] [stdout]      |
[INFO] [stdout] 3161 |             return Ok(Self::GetAssignmentResponse(m0.into()));
[INFO] [stdout]      |                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3161 -             return Ok(Self::GetAssignmentResponse(m0.into()));
[INFO] [stdout] 3161 +             return Ok(Self::GetAssignmentResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3161 -             return Ok(Self::GetAssignmentResponse(m0.into()));
[INFO] [stdout] 3161 +             return Ok(Self::GetAssignmentResponse(<GetAssignmentResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `GetAssertionsResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3166:51
[INFO] [stdout]      |
[INFO] [stdout] 3166 |             return Ok(Self::GetAssertionsResponse(m0.into()));
[INFO] [stdout]      |                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(Self::GetAssertionsResponse(m0.into()));
[INFO] [stdout] 3166 +             return Ok(Self::GetAssertionsResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3166 -             return Ok(Self::GetAssertionsResponse(m0.into()));
[INFO] [stdout] 3166 +             return Ok(Self::GetAssertionsResponse(<GetAssertionsResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EvalResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3171:42
[INFO] [stdout]      |
[INFO] [stdout] 3171 |             return Ok(Self::EvalResponse(m0.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3171 -             return Ok(Self::EvalResponse(m0.into()));
[INFO] [stdout] 3171 +             return Ok(Self::EvalResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3171 -             return Ok(Self::EvalResponse(m0.into()));
[INFO] [stdout] 3171 +             return Ok(Self::EvalResponse(<EvalResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EchoResponse<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3176:42
[INFO] [stdout]      |
[INFO] [stdout] 3176 |             return Ok(Self::EchoResponse(m0.into()));
[INFO] [stdout]      |                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3176 -             return Ok(Self::EchoResponse(m0.into()));
[INFO] [stdout] 3176 +             return Ok(Self::EchoResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3176 -             return Ok(Self::EchoResponse(m0.into()));
[INFO] [stdout] 3176 +             return Ok(Self::EchoResponse(<EchoResponse<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `CheckSatResponse`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3181:46
[INFO] [stdout]      |
[INFO] [stdout] 3181 |             return Ok(Self::CheckSatResponse(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3181 -             return Ok(Self::CheckSatResponse(m0.into()));
[INFO] [stdout] 3181 +             return Ok(Self::CheckSatResponse(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3181 -             return Ok(Self::CheckSatResponse(m0.into()));
[INFO] [stdout] 3181 +             return Ok(Self::CheckSatResponse(<CheckSatResponse as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3294:51
[INFO] [stdout]      |
[INFO] [stdout] 3294 |             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout]      |                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3294 -             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout] 3294 +             return Ok(p.storage.alloc(Self::Match(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3294 -             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout] 3294 +             return Ok(p.storage.alloc(Self::Match(<&Term<'_> as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[MatchCase<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3294:62
[INFO] [stdout]      |
[INFO] [stdout] 3294 |             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout]      |                                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3294 -             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout] 3294 +             return Ok(p.storage.alloc(Self::Match(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3294 -             return Ok(p.storage.alloc(Self::Match(m0.into(), m1.into())));
[INFO] [stdout] 3294 +             return Ok(p.storage.alloc(Self::Match(m0.into(), <&[MatchCase<'_>] as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[VarBinding<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3308:49
[INFO] [stdout]      |
[INFO] [stdout] 3308 |             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout]      |                                                 ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout] 3308 +             return Ok(p.storage.alloc(Self::Let(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3308 -             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout] 3308 +             return Ok(p.storage.alloc(Self::Let(<&[VarBinding<'_>] as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3308:60
[INFO] [stdout]      |
[INFO] [stdout] 3308 |             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout]      |                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout] 3308 +             return Ok(p.storage.alloc(Self::Let(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3308 -             return Ok(p.storage.alloc(Self::Let(m0.into(), m1.into())));
[INFO] [stdout] 3308 +             return Ok(p.storage.alloc(Self::Let(m0.into(), <&Term<'_> as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[SortedVar<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3322:52
[INFO] [stdout]      |
[INFO] [stdout] 3322 |             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout]      |                                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3322 -             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout] 3322 +             return Ok(p.storage.alloc(Self::Forall(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3322 -             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout] 3322 +             return Ok(p.storage.alloc(Self::Forall(<&[SortedVar<'_>] as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3322:63
[INFO] [stdout]      |
[INFO] [stdout] 3322 |             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout]      |                                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3322 -             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout] 3322 +             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3322 -             return Ok(p.storage.alloc(Self::Forall(m0.into(), m1.into())));
[INFO] [stdout] 3322 +             return Ok(p.storage.alloc(Self::Forall(m0.into(), <&Term<'_> as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[SortedVar<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3336:52
[INFO] [stdout]      |
[INFO] [stdout] 3336 |             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout]      |                                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3336 -             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout] 3336 +             return Ok(p.storage.alloc(Self::Exists(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3336 -             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout] 3336 +             return Ok(p.storage.alloc(Self::Exists(<&[SortedVar<'_>] as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3336:63
[INFO] [stdout]      |
[INFO] [stdout] 3336 |             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout]      |                                                               ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3336 -             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout] 3336 +             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3336 -             return Ok(p.storage.alloc(Self::Exists(m0.into(), m1.into())));
[INFO] [stdout] 3336 +             return Ok(p.storage.alloc(Self::Exists(m0.into(), <&Term<'_> as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&Term<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3347:56
[INFO] [stdout]      |
[INFO] [stdout] 3347 |             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout]      |                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3347 -             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout] 3347 +             return Ok(p.storage.alloc(Self::Annotation(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3347 -             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout] 3347 +             return Ok(p.storage.alloc(Self::Annotation(<&Term<'_> as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[Attribute<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3347:67
[INFO] [stdout]      |
[INFO] [stdout] 3347 |             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout]      |                                                                   ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3347 -             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout] 3347 +             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3347 -             return Ok(p.storage.alloc(Self::Annotation(m0.into(), m1.into())));
[INFO] [stdout] 3347 +             return Ok(p.storage.alloc(Self::Annotation(m0.into(), <&[Attribute<'_>] as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpecConstant<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3352:58
[INFO] [stdout]      |
[INFO] [stdout] 3352 |             return Ok(p.storage.alloc(Self::SpecConstant(m0.into())));
[INFO] [stdout]      |                                                          ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3352 -             return Ok(p.storage.alloc(Self::SpecConstant(m0.into())));
[INFO] [stdout] 3352 +             return Ok(p.storage.alloc(Self::SpecConstant(m0)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3352 -             return Ok(p.storage.alloc(Self::SpecConstant(m0.into())));
[INFO] [stdout] 3352 +             return Ok(p.storage.alloc(Self::SpecConstant(<SpecConstant<'_> as Into<_>>::into(m0))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `QualIdentifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3357:56
[INFO] [stdout]      |
[INFO] [stdout] 3357 |             return Ok(p.storage.alloc(Self::Identifier(m0.into())));
[INFO] [stdout]      |                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3357 -             return Ok(p.storage.alloc(Self::Identifier(m0.into())));
[INFO] [stdout] 3357 +             return Ok(p.storage.alloc(Self::Identifier(m0)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3357 -             return Ok(p.storage.alloc(Self::Identifier(m0.into())));
[INFO] [stdout] 3357 +             return Ok(p.storage.alloc(Self::Identifier(<QualIdentifier<'_> as Into<_>>::into(m0))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `QualIdentifier<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3365:57
[INFO] [stdout]      |
[INFO] [stdout] 3365 |             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout]      |                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3365 -             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout] 3365 +             return Ok(p.storage.alloc(Self::Application(m0, m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3365 -             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout] 3365 +             return Ok(p.storage.alloc(Self::Application(<QualIdentifier<'_> as Into<_>>::into(m0), m1.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[&Term<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3365:68
[INFO] [stdout]      |
[INFO] [stdout] 3365 |             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout]      |                                                                    ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3365 -             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout] 3365 +             return Ok(p.storage.alloc(Self::Application(m0.into(), m1)));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3365 -             return Ok(p.storage.alloc(Self::Application(m0.into(), m1.into())));
[INFO] [stdout] 3365 +             return Ok(p.storage.alloc(Self::Application(m0.into(), <&[&Term<'_>] as Into<_>>::into(m1))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[SortSymbolDecl<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3435:72
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             #[allow(clippy::useless_conversion)] return Ok(Self::Sorts(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             #[allow(clippy::useless_conversion)] return Ok(Self::Sorts(m0.into()));
[INFO] [stdout] 3435 +             #[allow(clippy::useless_conversion)] return Ok(Self::Sorts(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             #[allow(clippy::useless_conversion)] return Ok(Self::Sorts(m0.into()));
[INFO] [stdout] 3435 +             #[allow(clippy::useless_conversion)] return Ok(Self::Sorts(<&[SortSymbolDecl<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&[ParFunSymbolDecl<'_>]`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3444:71
[INFO] [stdout]      |
[INFO] [stdout] 3444 |             #[allow(clippy::useless_conversion)] return Ok(Self::Funs(m0.into()));
[INFO] [stdout]      |                                                                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3444 -             #[allow(clippy::useless_conversion)] return Ok(Self::Funs(m0.into()));
[INFO] [stdout] 3444 +             #[allow(clippy::useless_conversion)] return Ok(Self::Funs(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3444 -             #[allow(clippy::useless_conversion)] return Ok(Self::Funs(m0.into()));
[INFO] [stdout] 3444 +             #[allow(clippy::useless_conversion)] return Ok(Self::Funs(<&[ParFunSymbolDecl<'_>] as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3449:73
[INFO] [stdout]      |
[INFO] [stdout] 3449 |             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout]      |                                                                         ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3449 -             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout] 3449 +             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3449 -             #[allow(clippy::useless_conversion)] return Ok(Self::Values(m0.into()));
[INFO] [stdout] 3449 +             #[allow(clippy::useless_conversion)] return Ok(Self::Values(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3455:46
[INFO] [stdout]      |
[INFO] [stdout] 3455 |             return Ok(Self::SortsDescription(m0.into()));
[INFO] [stdout]      |                                              ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3455 -             return Ok(Self::SortsDescription(m0.into()));
[INFO] [stdout] 3455 +             return Ok(Self::SortsDescription(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3455 -             return Ok(Self::SortsDescription(m0.into()));
[INFO] [stdout] 3455 +             return Ok(Self::SortsDescription(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3460:72
[INFO] [stdout]      |
[INFO] [stdout] 3460 |             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout]      |                                                                        ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3460 -             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout] 3460 +             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3460 -             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(m0.into()));
[INFO] [stdout] 3460 +             #[allow(clippy::useless_conversion)] return Ok(Self::Notes(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3466:45
[INFO] [stdout]      |
[INFO] [stdout] 3466 |             return Ok(Self::FunsDescription(m0.into()));
[INFO] [stdout]      |                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3466 -             return Ok(Self::FunsDescription(m0.into()));
[INFO] [stdout] 3466 +             return Ok(Self::FunsDescription(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3466 -             return Ok(Self::FunsDescription(m0.into()));
[INFO] [stdout] 3466 +             return Ok(Self::FunsDescription(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3471:77
[INFO] [stdout]      |
[INFO] [stdout] 3471 |             #[allow(clippy::useless_conversion)] return Ok(Self::Definition(m0.into()));
[INFO] [stdout]      |                                                                             ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3471 -             #[allow(clippy::useless_conversion)] return Ok(Self::Definition(m0.into()));
[INFO] [stdout] 3471 +             #[allow(clippy::useless_conversion)] return Ok(Self::Definition(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3471 -             #[allow(clippy::useless_conversion)] return Ok(Self::Definition(m0.into()));
[INFO] [stdout] 3471 +             #[allow(clippy::useless_conversion)] return Ok(Self::Definition(<&str as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Attribute<'_>`
[INFO] [stdout]     --> lowlevel/src/ast.rs:3475:76
[INFO] [stdout]      |
[INFO] [stdout] 3475 |             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout]      |                                                                            ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3475 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 3475 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3475 -             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(m0.into()));
[INFO] [stdout] 3475 +             #[allow(clippy::useless_conversion)] return Ok(Self::Attribute(<Attribute<'_> as Into<_>>::into(m0)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `smtlib-lowlevel` (lib) due to 159 previous errors
[INFO] running `Command { std: "docker" "inspect" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e", kill_on_drop: false }`
[INFO] [stdout] b0cb30a2201e07e40b8b54705d4f0315d4f268c61cb0d2fd54ee41ca84ac218e
