[INFO] cloning repository https://github.com/monad-lang/monad
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/monad-lang/monad" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fmonad-lang%2Fmonad", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fmonad-lang%2Fmonad'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 31fc8779198c6e1c000514b1a031972eb3c73456
[INFO] checking monad-lang/monad against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fmonad-lang%2Fmonad" "/workspace/builds/worker-5-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-5-tc2/source'...
[INFO] [stderr] done.
[INFO] removed /workspace/builds/worker-5-tc2/source/.cargo/config.toml
[INFO] started tweaking git repo https://github.com/monad-lang/monad
[INFO] finished tweaking git repo https://github.com/monad-lang/monad
[INFO] tweaked toml for git repo https://github.com/monad-lang/monad written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/monad-lang/monad 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/monad-lang/monad 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 `homepage` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:29:1
[INFO] [stderr]    |
[INFO] [stderr] 29 | homepage = "https://monad-lang.org"
[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.homepage`
[INFO] [stderr] warning: unused field `repository` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:31:1
[INFO] [stderr]    |
[INFO] [stderr] 31 | repository = "https://tangled.org/monad-lang.org/monad"
[INFO] [stderr]    | ^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the field `workspace.package.repository`
[INFO] [stderr] warning: workspace (manifest) generated 2 warnings
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb
[INFO] running `Command { std: "docker" "start" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb", 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" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb", 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" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: unused field `homepage` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:29:1
[INFO] [stderr]    |
[INFO] [stderr] 29 | homepage = "https://monad-lang.org"
[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.homepage`
[INFO] [stderr] warning: unused field `repository` in `workspace.package`
[INFO] [stderr]   --> Cargo.toml:31:1
[INFO] [stderr]    |
[INFO] [stderr] 31 | repository = "https://tangled.org/monad-lang.org/monad"
[INFO] [stderr]    | ^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the field `workspace.package.repository`
[INFO] [stderr] warning: workspace (manifest) generated 2 warnings
[INFO] [stderr]    Compiling wasm-bindgen-shared v0.2.118
[INFO] [stderr]    Compiling bumpalo v3.20.2
[INFO] [stderr]    Compiling libc v0.2.185
[INFO] [stderr]     Checking unicode-ident v1.0.24
[INFO] [stderr]    Compiling nix v0.30.1
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]    Compiling wasm-bindgen v0.2.118
[INFO] [stderr]     Checking serde_json v1.0.149
[INFO] [stderr]     Checking nibble_vec v0.1.0
[INFO] [stderr]     Checking bitmaps v2.1.0
[INFO] [stderr]    Compiling im v15.1.0
[INFO] [stderr]     Checking endian-type v0.1.2
[INFO] [stderr]     Checking rand_core v0.6.4
[INFO] [stderr]     Checking winnow v0.7.15
[INFO] [stderr]    Compiling crossbeam-utils v0.8.22
[INFO] [stderr]     Checking fd-lock v4.0.4
[INFO] [stderr]    Compiling zerocopy v0.8.55
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.20
[INFO] [stderr]     Checking nom v8.0.0
[INFO] [stderr]     Checking rand_xoshiro v0.6.0
[INFO] [stderr]     Checking radix_trie v0.2.1
[INFO] [stderr]    Compiling crossbeam-deque v0.8.7
[INFO] [stderr]     Checking clap_builder v4.6.0
[INFO] [stderr]     Checking either v1.17.0
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]    Compiling libmimalloc-sys v0.1.49
[INFO] [stderr]     Checking itertools v0.10.5
[INFO] [stderr]     Checking sized-chunks v0.6.5
[INFO] [stderr]     Checking rayon-core v1.13.0
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking regex v1.13.1
[INFO] [stderr]     Checking mimalloc v0.1.52
[INFO] [stderr]     Checking is-terminal v0.4.17
[INFO] [stderr]     Checking criterion-plot v0.5.0
[INFO] [stderr]     Checking rustyline v17.0.2
[INFO] [stderr]    Compiling wasm-bindgen-macro-support v0.2.118
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling zerocopy-derive v0.8.55
[INFO] [stderr]    Compiling clap_derive v4.6.1
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]    Compiling wasm-bindgen-macro v0.2.118
[INFO] [stderr]     Checking serde v1.0.228
[INFO] [stderr]     Checking console_error_panic_hook v0.1.7
[INFO] [stderr]     Checking js-sys v0.3.95
[INFO] [stderr]     Checking serde_spanned v0.6.9
[INFO] [stderr]     Checking toml_datetime v0.6.11
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking toml_edit v0.22.27
[INFO] [stderr]     Checking toml v0.8.23
[INFO] [stderr]     Checking monad-core v0.1.0 (/opt/rustwide/workdir/core)
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking criterion v0.5.1
[INFO] [stderr]     Checking serde-wasm-bindgen v0.6.5
[INFO] [stderr]     Checking monad-wasm v0.1.0 (/opt/rustwide/workdir/wasm)
[INFO] [stderr]     Checking monad-cli v0.1.0 (/opt/rustwide/workdir/rust-cli)
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/eval/derive_cli_test.rs:56:27
[INFO] [stdout]    |
[INFO] [stdout] 56 |   let parsed = parse_file(full_source.as_str().into()).map_err(|e| e.to_string())?;
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 56 -   let parsed = parse_file(full_source.as_str().into()).map_err(|e| e.to_string())?;
[INFO] [stdout] 56 +   let parsed = parse_file(full_source.as_str()).map_err(|e| e.to_string())?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -   let parsed = parse_file(full_source.as_str().into()).map_err(|e| e.to_string())?;
[INFO] [stdout] 56 +   let parsed = parse_file(<&str as Into<_>>::into(full_source.as_str())).map_err(|e| e.to_string())?;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/eval/macro_test.rs:217:27
[INFO] [stdout]     |
[INFO] [stdout] 217 |   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 217 +   let parsed = parse_file(input).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 217 +   let parsed = parse_file(<&str as Into<_>>::into(input)).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/eval/macro_test.rs:239:27
[INFO] [stdout]     |
[INFO] [stdout] 239 |   let parsed = parse_file(input.into()).unwrap_or_else(|e| {
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 239 -   let parsed = parse_file(input.into()).unwrap_or_else(|e| {
[INFO] [stdout] 239 +   let parsed = parse_file(input).unwrap_or_else(|e| {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 -   let parsed = parse_file(input.into()).unwrap_or_else(|e| {
[INFO] [stdout] 239 +   let parsed = parse_file(<&str as Into<_>>::into(input)).unwrap_or_else(|e| {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/eval/macro_test.rs:416:27
[INFO] [stdout]     |
[INFO] [stdout] 416 |   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 416 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 416 +   let parsed = parse_file(input).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 416 +   let parsed = parse_file(<&str as Into<_>>::into(input)).map_err(|e| format!("{e}"))?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/eval/meta_compile_spike_test.rs:43:5
[INFO] [stdout]    |
[INFO] [stdout] 43 | /     r#"
[INFO] [stdout] 44 | |     use init
[INFO] [stdout] 45 | |
[INFO] [stdout] 46 | |     def bump (n : I64) : I64 := I64.add n 5
[INFO] [stdout] 47 | |     "#
[INFO] [stdout] 48 | |     .into(),
[INFO] [stdout]    | |___________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 47 -     "#
[INFO] [stdout] 48 -     .into(),
[INFO] [stdout] 47 +     "#,
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 44 |     use init
[INFO] [stdout] 45 |
[INFO] [stdout] 46 |     def bump (n : I64) : I64 := I64.add n 5
[INFO] [stdout] 47 ~     "#),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/eval/meta_test.rs:48:27
[INFO] [stdout]    |
[INFO] [stdout] 48 |   let parsed = parse_file(include_str!("../../../init/src/meta.mo").into()).unwrap();
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/eval/meta_test.rs:62:27
[INFO] [stdout]    |
[INFO] [stdout] 62 |   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout]    |                           ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 62 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 62 +   let parsed = parse_file(input).map_err(|e| format!("{e}"))?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -   let parsed = parse_file(input.into()).map_err(|e| format!("{e}"))?;
[INFO] [stdout] 62 +   let parsed = parse_file(<&str as Into<_>>::into(input)).map_err(|e| format!("{e}"))?;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/eval/meta_test.rs:85:5
[INFO] [stdout]    |
[INFO] [stdout] 85 | /     r#"
[INFO] [stdout] 86 | |     use init::meta {TypeInfo, Decl, Expr}
[INFO] [stdout] 87 | |
[INFO] [stdout] 88 | |     struct Point { x : I64, y : I64 }
[INFO] [stdout] ...  |
[INFO] [stdout] 97 | |     "#
[INFO] [stdout] 98 | |     .into(),
[INFO] [stdout]    | |___________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 97 -     "#
[INFO] [stdout] 98 -     .into(),
[INFO] [stdout] 97 +     "#,
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 86 |     use init::meta {TypeInfo, Decl, Expr}
[INFO] [stdout] ...
[INFO] [stdout] 96 |     reflect_type_info! Point my_meta
[INFO] [stdout] 97 ~     "#),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/eval/meta_test.rs:185:5
[INFO] [stdout]     |
[INFO] [stdout] 185 | /     r#"
[INFO] [stdout] 186 | |     use std::derive {derive_lens}
[INFO] [stdout] 187 | |
[INFO] [stdout] 188 | |     struct Point { x : I64, y : I64 }
[INFO] [stdout] ...   |
[INFO] [stdout] 191 | |     "#
[INFO] [stdout] 192 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 191 -     "#
[INFO] [stdout] 192 -     .into(),
[INFO] [stdout] 191 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 185 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 186 |     use std::derive {derive_lens}
[INFO] [stdout] ...
[INFO] [stdout] 190 |     derive_lens! Point
[INFO] [stdout] 191 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/attributes.rs:752:11
[INFO] [stdout]     |
[INFO] [stdout] 752 |     let s = r#"#![mote { name := "x" }]
[INFO] [stdout]     |  ___________^
[INFO] [stdout] 753 | |     def foo : I64 := 1
[INFO] [stdout] 754 | |     "#
[INFO] [stdout] 755 | |   .into();
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 754 -     "#
[INFO] [stdout] 755 -   .into();
[INFO] [stdout] 754 +     "#;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 752 ~   let s = <&str as Into<_>>::into(r#"#![mote { name := "x" }]
[INFO] [stdout] 753 |     def foo : I64 := 1
[INFO] [stdout] 754 ~     "#);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]  --> core/src/parser/test/basics.rs:7:19
[INFO] [stdout]   |
[INFO] [stdout] 7 |   similar!(r, str(r#"It's a test "Hello, World""#.into()));
[INFO] [stdout]   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]   |
[INFO] [stdout] 7 -   similar!(r, str(r#"It's a test "Hello, World""#.into()));
[INFO] [stdout] 7 +   similar!(r, str(r#"It's a test "Hello, World""#));
[INFO] [stdout]   |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 7 -   similar!(r, str(r#"It's a test "Hello, World""#.into()));
[INFO] [stdout] 7 +   similar!(r, str(<&str as Into<_>>::into(r#"It's a test "Hello, World""#)));
[INFO] [stdout]   |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/parser/test/basics.rs:20:19
[INFO] [stdout]    |
[INFO] [stdout] 20 |   similar!(r, str("hello".into()));
[INFO] [stdout]    |                   ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 20 -   similar!(r, str("hello".into()));
[INFO] [stdout] 20 +   similar!(r, str("hello"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 20 -   similar!(r, str("hello".into()));
[INFO] [stdout] 20 +   similar!(r, str(<&str as Into<_>>::into("hello")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/parser/test/basics.rs:24:19
[INFO] [stdout]    |
[INFO] [stdout] 24 |   similar!(r, str(" blab\"\"\" ".into()));
[INFO] [stdout]    |                   ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 24 -   similar!(r, str(" blab\"\"\" ".into()));
[INFO] [stdout] 24 +   similar!(r, str(" blab\"\"\" "));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 -   similar!(r, str(" blab\"\"\" ".into()));
[INFO] [stdout] 24 +   similar!(r, str(<&str as Into<_>>::into(" blab\"\"\" ")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:124:26
[INFO] [stdout]     |
[INFO] [stdout] 124 |   let (_, r) = def_param(r#"(a : String)"#.into()).unwrap();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 124 -   let (_, r) = def_param(r#"(a : String)"#.into()).unwrap();
[INFO] [stdout] 124 +   let (_, r) = def_param(r#"(a : String)"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 124 -   let (_, r) = def_param(r#"(a : String)"#.into()).unwrap();
[INFO] [stdout] 124 +   let (_, r) = def_param(<&str as Into<_>>::into(r#"(a : String)"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:126:26
[INFO] [stdout]     |
[INFO] [stdout] 126 |   let (_, r) = def_param(r#"(a b : String)"#.into()).unwrap();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 126 -   let (_, r) = def_param(r#"(a b : String)"#.into()).unwrap();
[INFO] [stdout] 126 +   let (_, r) = def_param(r#"(a b : String)"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 126 -   let (_, r) = def_param(r#"(a b : String)"#.into()).unwrap();
[INFO] [stdout] 126 +   let (_, r) = def_param(<&str as Into<_>>::into(r#"(a b : String)"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:128:26
[INFO] [stdout]     |
[INFO] [stdout] 128 |   let (_, r) = def_param(r#"(a : String -> Option Int)"#.into()).unwrap();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 128 -   let (_, r) = def_param(r#"(a : String -> Option Int)"#.into()).unwrap();
[INFO] [stdout] 128 +   let (_, r) = def_param(r#"(a : String -> Option Int)"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 -   let (_, r) = def_param(r#"(a : String -> Option Int)"#.into()).unwrap();
[INFO] [stdout] 128 +   let (_, r) = def_param(<&str as Into<_>>::into(r#"(a : String -> Option Int)"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:141:31
[INFO] [stdout]     |
[INFO] [stdout] 141 |   let (_, brace) = def_params(r#"{factor : I64, p : I64}"#.into()).unwrap();
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 141 -   let (_, brace) = def_params(r#"{factor : I64, p : I64}"#.into()).unwrap();
[INFO] [stdout] 141 +   let (_, brace) = def_params(r#"{factor : I64, p : I64}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 -   let (_, brace) = def_params(r#"{factor : I64, p : I64}"#.into()).unwrap();
[INFO] [stdout] 141 +   let (_, brace) = def_params(<&str as Into<_>>::into(r#"{factor : I64, p : I64}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:142:31
[INFO] [stdout]     |
[INFO] [stdout] 142 |   let (_, paren) = def_params(r#"(factor : I64) (p : I64)"#.into()).unwrap();
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 142 -   let (_, paren) = def_params(r#"(factor : I64) (p : I64)"#.into()).unwrap();
[INFO] [stdout] 142 +   let (_, paren) = def_params(r#"(factor : I64) (p : I64)"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 -   let (_, paren) = def_params(r#"(factor : I64) (p : I64)"#.into()).unwrap();
[INFO] [stdout] 142 +   let (_, paren) = def_params(<&str as Into<_>>::into(r#"(factor : I64) (p : I64)"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:153:27
[INFO] [stdout]     |
[INFO] [stdout] 153 |   let (_, r) = def_params(r#"{factor : I64 := 1, p : I64}"#.into()).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 153 -   let (_, r) = def_params(r#"{factor : I64 := 1, p : I64}"#.into()).unwrap();
[INFO] [stdout] 153 +   let (_, r) = def_params(r#"{factor : I64 := 1, p : I64}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 -   let (_, r) = def_params(r#"{factor : I64 := 1, p : I64}"#.into()).unwrap();
[INFO] [stdout] 153 +   let (_, r) = def_params(<&str as Into<_>>::into(r#"{factor : I64 := 1, p : I64}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:599:11
[INFO] [stdout]     |
[INFO] [stdout] 599 |     let s = r#"struct MyData {
[INFO] [stdout]     |  ___________^
[INFO] [stdout] 600 | |         data : MyData,
[INFO] [stdout] 601 | |         field_type : Type,
[INFO] [stdout] 602 | |         text : String := "default",
[INFO] [stdout] 603 | |     }
[INFO] [stdout] 604 | |     "#
[INFO] [stdout] 605 | |   .into();
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 604 -     "#
[INFO] [stdout] 605 -   .into();
[INFO] [stdout] 604 +     "#;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 599 ~   let s = <&str as Into<_>>::into(r#"struct MyData {
[INFO] [stdout] 600 |         data : MyData,
[INFO] [stdout] ...
[INFO] [stdout] 603 |     }
[INFO] [stdout] 604 ~     "#);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:622:11
[INFO] [stdout]     |
[INFO] [stdout] 622 |     let s = r#"struct [Serialize M] MyData (M: Type) {
[INFO] [stdout]     |  ___________^
[INFO] [stdout] 623 | |          data : M,
[INFO] [stdout] 624 | |          text : String := "default",
[INFO] [stdout] ...   |
[INFO] [stdout] 627 | |   .into();
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 626 -      "#
[INFO] [stdout] 627 -   .into();
[INFO] [stdout] 626 +      "#;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 622 ~   let s = <&str as Into<_>>::into(r#"struct [Serialize M] MyData (M: Type) {
[INFO] [stdout] 623 |          data : M,
[INFO] [stdout] 624 |          text : String := "default",
[INFO] [stdout] 625 |      }
[INFO] [stdout] 626 ~      "#);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/declarations.rs:812:33
[INFO] [stdout]     |
[INFO] [stdout] 812 |   let m: Vec<Decl> = parse_file(s.into())
[INFO] [stdout]     |                                 ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 812 -   let m: Vec<Decl> = parse_file(s.into())
[INFO] [stdout] 812 +   let m: Vec<Decl> = parse_file(s)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 -   let m: Vec<Decl> = parse_file(s.into())
[INFO] [stdout] 812 +   let m: Vec<Decl> = parse_file(<&str as Into<_>>::into(s))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]  --> core/src/parser/test/expressions.rs:6:23
[INFO] [stdout]   |
[INFO] [stdout] 6 |   let (_, r) = lambda(r#"\a => a"#.into()).unwrap();
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]   |
[INFO] [stdout] 6 -   let (_, r) = lambda(r#"\a => a"#.into()).unwrap();
[INFO] [stdout] 6 +   let (_, r) = lambda(r#"\a => a"#).unwrap();
[INFO] [stdout]   |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 6 -   let (_, r) = lambda(r#"\a => a"#.into()).unwrap();
[INFO] [stdout] 6 +   let (_, r) = lambda(<&str as Into<_>>::into(r#"\a => a"#)).unwrap();
[INFO] [stdout]   |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]  --> core/src/parser/test/expressions.rs:9:23
[INFO] [stdout]   |
[INFO] [stdout] 9 |   let (_, r) = lambda("\\a b \n=>\n a".into()).unwrap();
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]   |
[INFO] [stdout] 9 -   let (_, r) = lambda("\\a b \n=>\n a".into()).unwrap();
[INFO] [stdout] 9 +   let (_, r) = lambda("\\a b \n=>\n a").unwrap();
[INFO] [stdout]   |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 9 -   let (_, r) = lambda("\\a b \n=>\n a".into()).unwrap();
[INFO] [stdout] 9 +   let (_, r) = lambda(<&str as Into<_>>::into("\\a b \n=>\n a")).unwrap();
[INFO] [stdout]   |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/parser/test/expressions.rs:24:23
[INFO] [stdout]    |
[INFO] [stdout] 24 |   let (_, r) = lambda(r#"\({ x, y } : Point) => x + y"#.into()).unwrap();
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 24 -   let (_, r) = lambda(r#"\({ x, y } : Point) => x + y"#.into()).unwrap();
[INFO] [stdout] 24 +   let (_, r) = lambda(r#"\({ x, y } : Point) => x + y"#).unwrap();
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 -   let (_, r) = lambda(r#"\({ x, y } : Point) => x + y"#.into()).unwrap();
[INFO] [stdout] 24 +   let (_, r) = lambda(<&str as Into<_>>::into(r#"\({ x, y } : Point) => x + y"#)).unwrap();
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/parser/test/expressions.rs:64:23
[INFO] [stdout]    |
[INFO] [stdout] 64 |   let (_, r) = lambda(r#"\({ x, y } : Point) factor => x * factor"#.into()).unwrap();
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 64 -   let (_, r) = lambda(r#"\({ x, y } : Point) factor => x * factor"#.into()).unwrap();
[INFO] [stdout] 64 +   let (_, r) = lambda(r#"\({ x, y } : Point) factor => x * factor"#).unwrap();
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 -   let (_, r) = lambda(r#"\({ x, y } : Point) factor => x * factor"#.into()).unwrap();
[INFO] [stdout] 64 +   let (_, r) = lambda(<&str as Into<_>>::into(r#"\({ x, y } : Point) factor => x * factor"#)).unwrap();
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:114:5
[INFO] [stdout]     |
[INFO] [stdout] 114 | /     "match l {
[INFO] [stdout] 115 | |         empty => none,
[INFO] [stdout] 116 | |         cons a tail => some a
[INFO] [stdout] ...   |
[INFO] [stdout] 119 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -     "
[INFO] [stdout] 119 -     .into(),
[INFO] [stdout] 118 +     ",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 ~     <&str as Into<_>>::into("match l {
[INFO] [stdout] 115 |         empty => none,
[INFO] [stdout] 116 |         cons a tail => some a
[INFO] [stdout] 117 |     }
[INFO] [stdout] 118 ~     "),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:142:5
[INFO] [stdout]     |
[INFO] [stdout] 142 | /     "match Option.none {
[INFO] [stdout] 143 | |       Option.some val => val,
[INFO] [stdout] 144 | |       Option.none => 42
[INFO] [stdout] 145 | |     }"
[INFO] [stdout] 146 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -     }"
[INFO] [stdout] 146 -     .into(),
[INFO] [stdout] 145 +     }",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 ~     <&str as Into<_>>::into("match Option.none {
[INFO] [stdout] 143 |       Option.some val => val,
[INFO] [stdout] 144 |       Option.none => 42
[INFO] [stdout] 145 ~     }"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:170:34
[INFO] [stdout]     |
[INFO] [stdout] 170 |   let (_, r) = match_case_parser("{ a, b } => a".into()).unwrap();
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 170 -   let (_, r) = match_case_parser("{ a, b } => a".into()).unwrap();
[INFO] [stdout] 170 +   let (_, r) = match_case_parser("{ a, b } => a").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 -   let (_, r) = match_case_parser("{ a, b } => a".into()).unwrap();
[INFO] [stdout] 170 +   let (_, r) = match_case_parser(<&str as Into<_>>::into("{ a, b } => a")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:186:34
[INFO] [stdout]     |
[INFO] [stdout] 186 |   let (_, r) = match_case_parser("{ a := b, .. } => a".into()).unwrap();
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 186 -   let (_, r) = match_case_parser("{ a := b, .. } => a".into()).unwrap();
[INFO] [stdout] 186 +   let (_, r) = match_case_parser("{ a := b, .. } => a").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 -   let (_, r) = match_case_parser("{ a := b, .. } => a".into()).unwrap();
[INFO] [stdout] 186 +   let (_, r) = match_case_parser(<&str as Into<_>>::into("{ a := b, .. } => a")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:199:34
[INFO] [stdout]     |
[INFO] [stdout] 199 |   let (_, r) = match_case_parser("{ } => 0".into()).unwrap();
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 199 -   let (_, r) = match_case_parser("{ } => 0".into()).unwrap();
[INFO] [stdout] 199 +   let (_, r) = match_case_parser("{ } => 0").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 -   let (_, r) = match_case_parser("{ } => 0".into()).unwrap();
[INFO] [stdout] 199 +   let (_, r) = match_case_parser(<&str as Into<_>>::into("{ } => 0")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:213:5
[INFO] [stdout]     |
[INFO] [stdout] 213 | /     "match s {
[INFO] [stdout] 214 | |       circle { radius } => radius,
[INFO] [stdout] 215 | |       rectangle { width, height } => width
[INFO] [stdout] 216 | |     }"
[INFO] [stdout] 217 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 216 -     }"
[INFO] [stdout] 217 -     .into(),
[INFO] [stdout] 216 +     }",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 ~     <&str as Into<_>>::into("match s {
[INFO] [stdout] 214 |       circle { radius } => radius,
[INFO] [stdout] 215 |       rectangle { width, height } => width
[INFO] [stdout] 216 ~     }"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:250:34
[INFO] [stdout]     |
[INFO] [stdout] 250 |   let (_, r) = match_case_parser("some a => a".into()).unwrap();
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 250 -   let (_, r) = match_case_parser("some a => a".into()).unwrap();
[INFO] [stdout] 250 +   let (_, r) = match_case_parser("some a => a").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 -   let (_, r) = match_case_parser("some a => a".into()).unwrap();
[INFO] [stdout] 250 +   let (_, r) = match_case_parser(<&str as Into<_>>::into("some a => a")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:259:26
[INFO] [stdout]     |
[INFO] [stdout] 259 |   let (_, r) = if_parser("if var || var2 then a b else c".into()).unwrap();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -   let (_, r) = if_parser("if var || var2 then a b else c".into()).unwrap();
[INFO] [stdout] 259 +   let (_, r) = if_parser("if var || var2 then a b else c").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -   let (_, r) = if_parser("if var || var2 then a b else c".into()).unwrap();
[INFO] [stdout] 259 +   let (_, r) = if_parser(<&str as Into<_>>::into("if var || var2 then a b else c")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:273:27
[INFO] [stdout]     |
[INFO] [stdout] 273 |   let (_, r) = let_parser("let x := 12 in x".into()).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 273 -   let (_, r) = let_parser("let x := 12 in x".into()).unwrap();
[INFO] [stdout] 273 +   let (_, r) = let_parser("let x := 12 in x").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 -   let (_, r) = let_parser("let x := 12 in x".into()).unwrap();
[INFO] [stdout] 273 +   let (_, r) = let_parser(<&str as Into<_>>::into("let x := 12 in x")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:285:27
[INFO] [stdout]     |
[INFO] [stdout] 285 |   let (_, r) = let_parser(r#"let x := 12;y:="Hello" in combine x y"#.into()).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -   let (_, r) = let_parser(r#"let x := 12;y:="Hello" in combine x y"#.into()).unwrap();
[INFO] [stdout] 285 +   let (_, r) = let_parser(r#"let x := 12;y:="Hello" in combine x y"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -   let (_, r) = let_parser(r#"let x := 12;y:="Hello" in combine x y"#.into()).unwrap();
[INFO] [stdout] 285 +   let (_, r) = let_parser(<&str as Into<_>>::into(r#"let x := 12;y:="Hello" in combine x y"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:305:5
[INFO] [stdout]     |
[INFO] [stdout] 305 | /     r#"let x := 12
[INFO] [stdout] 306 | |         z : String := "test";
[INFO] [stdout] 307 | |         y := add x 13
[INFO] [stdout] 308 | |         in combine x y"#
[INFO] [stdout] 309 | |       .into(),
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 308 -         in combine x y"#
[INFO] [stdout] 309 -       .into(),
[INFO] [stdout] 308 +         in combine x y"#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 ~     <&str as Into<_>>::into(r#"let x := 12
[INFO] [stdout] 306 |         z : String := "test";
[INFO] [stdout] 307 |         y := add x 13
[INFO] [stdout] 308 ~         in combine x y"#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:340:18
[INFO] [stdout]     |
[INFO] [stdout] 340 |   let (_, r) = p(r#"{}"#.into()).unwrap();
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 340 -   let (_, r) = p(r#"{}"#.into()).unwrap();
[INFO] [stdout] 340 +   let (_, r) = p(r#"{}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 -   let (_, r) = p(r#"{}"#.into()).unwrap();
[INFO] [stdout] 340 +   let (_, r) = p(<&str as Into<_>>::into(r#"{}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:350:18
[INFO] [stdout]     |
[INFO] [stdout] 350 |   let (_, r) = p(r#"{a := b}"#.into()).unwrap();
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 350 -   let (_, r) = p(r#"{a := b}"#.into()).unwrap();
[INFO] [stdout] 350 +   let (_, r) = p(r#"{a := b}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 -   let (_, r) = p(r#"{a := b}"#.into()).unwrap();
[INFO] [stdout] 350 +   let (_, r) = p(<&str as Into<_>>::into(r#"{a := b}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:360:18
[INFO] [stdout]     |
[INFO] [stdout] 360 |   let (_, r) = p(r#"{a := b, b:={c:=0},}"#.into()).unwrap();
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -   let (_, r) = p(r#"{a := b, b:={c:=0},}"#.into()).unwrap();
[INFO] [stdout] 360 +   let (_, r) = p(r#"{a := b, b:={c:=0},}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -   let (_, r) = p(r#"{a := b, b:={c:=0},}"#.into()).unwrap();
[INFO] [stdout] 360 +   let (_, r) = p(<&str as Into<_>>::into(r#"{a := b, b:={c:=0},}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:381:18
[INFO] [stdout]     |
[INFO] [stdout] 381 |   let (_, r) = p(r#"{a := b : Point}"#.into()).unwrap();
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 381 -   let (_, r) = p(r#"{a := b : Point}"#.into()).unwrap();
[INFO] [stdout] 381 +   let (_, r) = p(r#"{a := b : Point}"#).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 -   let (_, r) = p(r#"{a := b : Point}"#.into()).unwrap();
[INFO] [stdout] 381 +   let (_, r) = p(<&str as Into<_>>::into(r#"{a := b : Point}"#)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/parser/test/expressions.rs:408:43
[INFO] [stdout]     |
[INFO] [stdout] 408 |   let base_of = |s: &'static str| match p(s.into()).unwrap().1 {
[INFO] [stdout]     |                                           ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 408 -   let base_of = |s: &'static str| match p(s.into()).unwrap().1 {
[INFO] [stdout] 408 +   let base_of = |s: &'static str| match p(s).unwrap().1 {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 408 -   let base_of = |s: &'static str| match p(s.into()).unwrap().1 {
[INFO] [stdout] 408 +   let base_of = |s: &'static str| match p(<&str as Into<_>>::into(s)).unwrap().1 {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/term/module/test.rs:24:14
[INFO] [stdout]    |
[INFO] [stdout] 24 |   parse_file(source.into())
[INFO] [stdout]    |              ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 24 -   parse_file(source.into())
[INFO] [stdout] 24 +   parse_file(source)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 -   parse_file(source.into())
[INFO] [stdout] 24 +   parse_file(<&str as Into<_>>::into(source))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/term/module/test.rs:40:14
[INFO] [stdout]    |
[INFO] [stdout] 40 |   parse_file(source.into())
[INFO] [stdout]    |              ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 40 -   parse_file(source.into())
[INFO] [stdout] 40 +   parse_file(source)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 -   parse_file(source.into())
[INFO] [stdout] 40 +   parse_file(<&str as Into<_>>::into(source))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> core/src/term/module/test.rs:95:26
[INFO] [stdout]    |
[INFO] [stdout] 95 |   let decls = parse_file("open IO {}\n".into()).unwrap().decls;
[INFO] [stdout]    |                          ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 95 -   let decls = parse_file("open IO {}\n".into()).unwrap().decls;
[INFO] [stdout] 95 +   let decls = parse_file("open IO {}\n").unwrap().decls;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 -   let decls = parse_file("open IO {}\n".into()).unwrap().decls;
[INFO] [stdout] 95 +   let decls = parse_file(<&str as Into<_>>::into("open IO {}\n")).unwrap().decls;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:106:26
[INFO] [stdout]     |
[INFO] [stdout] 106 |   let decls = parse_file("open IO {println}\n".into()).unwrap().decls;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 106 -   let decls = parse_file("open IO {println}\n".into()).unwrap().decls;
[INFO] [stdout] 106 +   let decls = parse_file("open IO {println}\n").unwrap().decls;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 -   let decls = parse_file("open IO {println}\n".into()).unwrap().decls;
[INFO] [stdout] 106 +   let decls = parse_file(<&str as Into<_>>::into("open IO {println}\n")).unwrap().decls;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:112:26
[INFO] [stdout]     |
[INFO] [stdout] 112 |   let decls = parse_file("open IO {*}\nopen Foo\n".into()).unwrap().decls;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 112 -   let decls = parse_file("open IO {*}\nopen Foo\n".into()).unwrap().decls;
[INFO] [stdout] 112 +   let decls = parse_file("open IO {*}\nopen Foo\n").unwrap().decls;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 112 -   let decls = parse_file("open IO {*}\nopen Foo\n".into()).unwrap().decls;
[INFO] [stdout] 112 +   let decls = parse_file(<&str as Into<_>>::into("open IO {*}\nopen Foo\n")).unwrap().decls;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:118:26
[INFO] [stdout]     |
[INFO] [stdout] 118 |   let decls = parse_file("open IO {} in def f : I64 := 1\n".into())
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -   let decls = parse_file("open IO {} in def f : I64 := 1\n".into())
[INFO] [stdout] 118 +   let decls = parse_file("open IO {} in def f : I64 := 1\n")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 -   let decls = parse_file("open IO {} in def f : I64 := 1\n".into())
[INFO] [stdout] 118 +   let decls = parse_file(<&str as Into<_>>::into("open IO {} in def f : I64 := 1\n"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:130:27
[INFO] [stdout]     |
[INFO] [stdout] 130 |   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 130 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 130 +   let parsed = parse_file(source).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 130 +   let parsed = parse_file(<&str as Into<_>>::into(source)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:209:26
[INFO] [stdout]     |
[INFO] [stdout] 209 |   let decls = parse_file(source.into()).expect("sample parses").decls;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 209 -   let decls = parse_file(source.into()).expect("sample parses").decls;
[INFO] [stdout] 209 +   let decls = parse_file(source).expect("sample parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 -   let decls = parse_file(source.into()).expect("sample parses").decls;
[INFO] [stdout] 209 +   let decls = parse_file(<&str as Into<_>>::into(source)).expect("sample parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:307:26
[INFO] [stdout]     |
[INFO] [stdout] 307 |   let decls = parse_file("use runtime {}\n".into()).expect("parses").decls;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -   let decls = parse_file("use runtime {}\n".into()).expect("parses").decls;
[INFO] [stdout] 307 +   let decls = parse_file("use runtime {}\n").expect("parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -   let decls = parse_file("use runtime {}\n".into()).expect("parses").decls;
[INFO] [stdout] 307 +   let decls = parse_file(<&str as Into<_>>::into("use runtime {}\n")).expect("parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:358:29
[INFO] [stdout]     |
[INFO] [stdout] 358 |     let parsed = parse_file((*target_src).into()).expect("target parses");
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 358 -     let parsed = parse_file((*target_src).into()).expect("target parses");
[INFO] [stdout] 358 +     let parsed = parse_file((*target_src)).expect("target parses");
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 -     let parsed = parse_file((*target_src).into()).expect("target parses");
[INFO] [stdout] 358 +     let parsed = parse_file(<&str as Into<_>>::into((*target_src))).expect("target parses");
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:367:26
[INFO] [stdout]     |
[INFO] [stdout] 367 |   let decls = parse_file(import_src.into()).expect("import parses").decls;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 367 -   let decls = parse_file(import_src.into()).expect("import parses").decls;
[INFO] [stdout] 367 +   let decls = parse_file(import_src).expect("import parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 367 -   let decls = parse_file(import_src.into()).expect("import parses").decls;
[INFO] [stdout] 367 +   let decls = parse_file(<&str as Into<_>>::into(import_src)).expect("import parses").decls;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:538:26
[INFO] [stdout]     |
[INFO] [stdout] 538 |   let decls = parse_file("use probe::absent {whatever}\n".into())
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 538 -   let decls = parse_file("use probe::absent {whatever}\n".into())
[INFO] [stdout] 538 +   let decls = parse_file("use probe::absent {whatever}\n")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 538 -   let decls = parse_file("use probe::absent {whatever}\n".into())
[INFO] [stdout] 538 +   let decls = parse_file(<&str as Into<_>>::into("use probe::absent {whatever}\n"))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:628:5
[INFO] [stdout]     |
[INFO] [stdout] 628 | /     r#"
[INFO] [stdout] 629 | |     def used_fn : I64 := 1
[INFO] [stdout] 630 | |     def unused_fn : I64 := 2
[INFO] [stdout] 631 | |     "#
[INFO] [stdout] 632 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 631 -     "#
[INFO] [stdout] 632 -     .into(),
[INFO] [stdout] 631 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 628 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 629 |     def used_fn : I64 := 1
[INFO] [stdout] 630 |     def unused_fn : I64 := 2
[INFO] [stdout] 631 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:652:29
[INFO] [stdout]     |
[INFO] [stdout] 652 |   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 652 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 652 +   let parsed_b = parse_file(source_b.as_str()).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 652 +   let parsed_b = parse_file(<&str as Into<_>>::into(source_b.as_str())).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:674:22
[INFO] [stdout]     |
[INFO] [stdout] 674 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 674 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 674 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 674 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 674 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:687:5
[INFO] [stdout]     |
[INFO] [stdout] 687 | /     r#"
[INFO] [stdout] 688 | |     def List.length : I64 := 1
[INFO] [stdout] 689 | |     def plain : I64 := 2
[INFO] [stdout] 690 | |     "#
[INFO] [stdout] 691 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 690 -     "#
[INFO] [stdout] 691 -     .into(),
[INFO] [stdout] 690 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 687 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 688 |     def List.length : I64 := 1
[INFO] [stdout] 689 |     def plain : I64 := 2
[INFO] [stdout] 690 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:711:29
[INFO] [stdout]     |
[INFO] [stdout] 711 |   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 711 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 711 +   let parsed_b = parse_file(source_b.as_str()).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 711 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 711 +   let parsed_b = parse_file(<&str as Into<_>>::into(source_b.as_str())).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:734:22
[INFO] [stdout]     |
[INFO] [stdout] 734 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 734 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 734 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 734 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 734 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:746:5
[INFO] [stdout]     |
[INFO] [stdout] 746 | /     r#"
[INFO] [stdout] 747 | |     def never_used : I64 := 1
[INFO] [stdout] 748 | |     "#
[INFO] [stdout] 749 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 748 -     "#
[INFO] [stdout] 749 -     .into(),
[INFO] [stdout] 748 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 746 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 747 |     def never_used : I64 := 1
[INFO] [stdout] 748 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:766:29
[INFO] [stdout]     |
[INFO] [stdout] 766 |   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 766 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 766 +   let parsed_b = parse_file(source_b.as_str()).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 766 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 766 +   let parsed_b = parse_file(<&str as Into<_>>::into(source_b.as_str())).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:784:22
[INFO] [stdout]     |
[INFO] [stdout] 784 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 784 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 784 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 784 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 784 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:798:29
[INFO] [stdout]     |
[INFO] [stdout] 798 |   let parsed_a = parse_file("def used_fn : I64 := 1\ndef unused_fn : I64 := 2\n".into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 798 -   let parsed_a = parse_file("def used_fn : I64 := 1\ndef unused_fn : I64 := 2\n".into()).unwrap();
[INFO] [stdout] 798 +   let parsed_a = parse_file("def used_fn : I64 := 1\ndef unused_fn : I64 := 2\n").unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 798 -   let parsed_a = parse_file("def used_fn : I64 := 1\ndef unused_fn : I64 := 2\n".into()).unwrap();
[INFO] [stdout] 798 +   let parsed_a = parse_file(<&str as Into<_>>::into("def used_fn : I64 := 1\ndef unused_fn : I64 := 2\n")).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:813:29
[INFO] [stdout]     |
[INFO] [stdout] 813 |   let parsed_b = parse_file(source_b.into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 813 -   let parsed_b = parse_file(source_b.into()).unwrap();
[INFO] [stdout] 813 +   let parsed_b = parse_file(source_b).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 813 -   let parsed_b = parse_file(source_b.into()).unwrap();
[INFO] [stdout] 813 +   let parsed_b = parse_file(<&str as Into<_>>::into(source_b)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:832:22
[INFO] [stdout]     |
[INFO] [stdout] 832 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 832 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 832 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 832 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 832 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:841:5
[INFO] [stdout]     |
[INFO] [stdout] 841 | /     r#"
[INFO] [stdout] 842 | |     def helper : I64 := 1
[INFO] [stdout] 843 | |     "#
[INFO] [stdout] 844 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 843 -     "#
[INFO] [stdout] 844 -     .into(),
[INFO] [stdout] 843 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 842 |     def helper : I64 := 1
[INFO] [stdout] 843 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:868:29
[INFO] [stdout]     |
[INFO] [stdout] 868 |   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 868 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 868 +   let parsed_b = parse_file(source_b.as_str()).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 -   let parsed_b = parse_file(source_b.as_str().into()).unwrap();
[INFO] [stdout] 868 +   let parsed_b = parse_file(<&str as Into<_>>::into(source_b.as_str())).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:893:22
[INFO] [stdout]     |
[INFO] [stdout] 893 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 893 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 893 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 893 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 893 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:920:27
[INFO] [stdout]     |
[INFO] [stdout] 920 |   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 920 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 920 +   let parsed = parse_file(source).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 920 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 920 +   let parsed = parse_file(<&str as Into<_>>::into(source)).unwrap();
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:941:22
[INFO] [stdout]     |
[INFO] [stdout] 941 |   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 941 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 941 +   assert!(parse_file(new_source.as_str()).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 -   assert!(parse_file(new_source.as_str().into()).is_ok());
[INFO] [stdout] 941 +   assert!(parse_file(<&str as Into<_>>::into(new_source.as_str())).is_ok());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> core/src/term/module/test.rs:964:5
[INFO] [stdout]     |
[INFO] [stdout] 964 | /     r#"
[INFO] [stdout] 965 | |     class HAdd A B C {
[INFO] [stdout] 966 | |       def add (a: A) (b : B) : C
[INFO] [stdout] ...   |
[INFO] [stdout] 976 | |     "#
[INFO] [stdout] 977 | |     .into(),
[INFO] [stdout]     | |___________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 976 -     "#
[INFO] [stdout] 977 -     .into(),
[INFO] [stdout] 976 +     "#,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 964 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 965 |     class HAdd A B C {
[INFO] [stdout] ...
[INFO] [stdout] 975 |     }
[INFO] [stdout] 976 ~     "#),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1010:5
[INFO] [stdout]      |
[INFO] [stdout] 1010 | /     r#"
[INFO] [stdout] 1011 | |     type MyType {
[INFO] [stdout] 1012 | |       constructor
[INFO] [stdout] ...    |
[INFO] [stdout] 1015 | |     "#
[INFO] [stdout] 1016 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1015 -     "#
[INFO] [stdout] 1016 -     .into(),
[INFO] [stdout] 1015 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1010 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1011 |     type MyType {
[INFO] [stdout]  ...
[INFO] [stdout] 1014 |     def my_def : MyType := MyType.constructor
[INFO] [stdout] 1015 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1043:5
[INFO] [stdout]      |
[INFO] [stdout] 1043 | /     r#"
[INFO] [stdout] 1044 | |     use init::io
[INFO] [stdout] 1045 | |     open IO
[INFO] [stdout] ...    |
[INFO] [stdout] 1048 | |     "#
[INFO] [stdout] 1049 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1048 -     "#
[INFO] [stdout] 1049 -     .into(),
[INFO] [stdout] 1048 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1043 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1044 |     use init::io
[INFO] [stdout]  ...
[INFO] [stdout] 1047 |     def test_def : IO Unit := println "test"
[INFO] [stdout] 1048 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1079:5
[INFO] [stdout]      |
[INFO] [stdout] 1079 | /     r#"
[INFO] [stdout] 1080 | |     use init::io
[INFO] [stdout] 1081 | |     open IO
[INFO] [stdout] ...    |
[INFO] [stdout] 1084 | |     "#
[INFO] [stdout] 1085 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1084 -     "#
[INFO] [stdout] 1085 -     .into(),
[INFO] [stdout] 1084 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1079 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1080 |     use init::io
[INFO] [stdout]  ...
[INFO] [stdout] 1083 |     def test_def : IO Unit := println "test"
[INFO] [stdout] 1084 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1113:5
[INFO] [stdout]      |
[INFO] [stdout] 1113 | /     r#"
[INFO] [stdout] 1114 | |     use init::io
[INFO] [stdout] 1115 | |     open IO
[INFO] [stdout] ...    |
[INFO] [stdout] 1118 | |     "#
[INFO] [stdout] 1119 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1118 -     "#
[INFO] [stdout] 1119 -     .into(),
[INFO] [stdout] 1118 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1113 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1114 |     use init::io
[INFO] [stdout]  ...
[INFO] [stdout] 1117 |     def test_def : String := "hello"
[INFO] [stdout] 1118 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1154:5
[INFO] [stdout]      |
[INFO] [stdout] 1154 | /     r#"
[INFO] [stdout] 1155 | |     use init
[INFO] [stdout] 1156 | |     use init::math
[INFO] [stdout] ...    |
[INFO] [stdout] 1159 | |     "#
[INFO] [stdout] 1160 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1159 -     "#
[INFO] [stdout] 1160 -     .into(),
[INFO] [stdout] 1159 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1154 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1155 |     use init
[INFO] [stdout]  ...
[INFO] [stdout] 1158 |     def test_eq : Bool := 1 == 1
[INFO] [stdout] 1159 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1190:5
[INFO] [stdout]      |
[INFO] [stdout] 1190 | /     r#"
[INFO] [stdout] 1191 | |     def shared_name : I64 := 1
[INFO] [stdout] 1192 | |     "#
[INFO] [stdout] 1193 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1192 -     "#
[INFO] [stdout] 1193 -     .into(),
[INFO] [stdout] 1192 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1190 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1191 |     def shared_name : I64 := 1
[INFO] [stdout] 1192 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1209:5
[INFO] [stdout]      |
[INFO] [stdout] 1209 | /     r#"
[INFO] [stdout] 1210 | |     def shared_name : I64 := 2
[INFO] [stdout] 1211 | |     "#
[INFO] [stdout] 1212 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1211 -     "#
[INFO] [stdout] 1212 -     .into(),
[INFO] [stdout] 1211 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1209 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1210 |     def shared_name : I64 := 2
[INFO] [stdout] 1211 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1300:5
[INFO] [stdout]      |
[INFO] [stdout] 1300 | /     r#"
[INFO] [stdout] 1301 | |     priv def secret_val : I64 := 42
[INFO] [stdout] 1302 | |     pub def public_val : I64 := 7
[INFO] [stdout] 1303 | |     def default_val : I64 := 1
[INFO] [stdout] 1304 | |     "#
[INFO] [stdout] 1305 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1304 -     "#
[INFO] [stdout] 1305 -     .into(),
[INFO] [stdout] 1304 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1300 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1301 |     priv def secret_val : I64 := 42
[INFO] [stdout] 1302 |     pub def public_val : I64 := 7
[INFO] [stdout] 1303 |     def default_val : I64 := 1
[INFO] [stdout] 1304 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1354:5
[INFO] [stdout]      |
[INFO] [stdout] 1354 | /     r#"
[INFO] [stdout] 1355 | |     def foo : I64 := 1
[INFO] [stdout] 1356 | |     def bar : I64 := 2
[INFO] [stdout] 1357 | |     "#
[INFO] [stdout] 1358 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1357 -     "#
[INFO] [stdout] 1358 -     .into(),
[INFO] [stdout] 1357 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1354 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1355 |     def foo : I64 := 1
[INFO] [stdout] 1356 |     def bar : I64 := 2
[INFO] [stdout] 1357 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1404:5
[INFO] [stdout]      |
[INFO] [stdout] 1404 | /     r#"
[INFO] [stdout] 1405 | |     def widget : I64 := 1
[INFO] [stdout] 1406 | |     "#
[INFO] [stdout] 1407 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1406 -     "#
[INFO] [stdout] 1407 -     .into(),
[INFO] [stdout] 1406 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1404 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1405 |     def widget : I64 := 1
[INFO] [stdout] 1406 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1428:29
[INFO] [stdout]      |
[INFO] [stdout] 1428 |   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1428 -   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout] 1428 +   let parsed_b = parse_file(source.as_str()).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1428 -   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout] 1428 +   let parsed_b = parse_file(<&str as Into<_>>::into(source.as_str())).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1457:29
[INFO] [stdout]      |
[INFO] [stdout] 1457 |   let parsed_b = parse_file(selected.as_str().into()).unwrap();
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1457 -   let parsed_b = parse_file(selected.as_str().into()).unwrap();
[INFO] [stdout] 1457 +   let parsed_b = parse_file(selected.as_str()).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1457 -   let parsed_b = parse_file(selected.as_str().into()).unwrap();
[INFO] [stdout] 1457 +   let parsed_b = parse_file(<&str as Into<_>>::into(selected.as_str())).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1495:5
[INFO] [stdout]      |
[INFO] [stdout] 1495 | /     r#"
[INFO] [stdout] 1496 | |     def widget : I64 := 1
[INFO] [stdout] 1497 | |     pub type Box2 { mk (x : I64) }
[INFO] [stdout] 1498 | |     "#
[INFO] [stdout] 1499 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1498 -     "#
[INFO] [stdout] 1499 -     .into(),
[INFO] [stdout] 1498 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1495 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1496 |     def widget : I64 := 1
[INFO] [stdout] 1497 |     pub type Box2 { mk (x : I64) }
[INFO] [stdout] 1498 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1521:29
[INFO] [stdout]      |
[INFO] [stdout] 1521 |   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1521 -   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout] 1521 +   let parsed_b = parse_file(source.as_str()).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1521 -   let parsed_b = parse_file(source.as_str().into()).unwrap();
[INFO] [stdout] 1521 +   let parsed_b = parse_file(<&str as Into<_>>::into(source.as_str())).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1553:5
[INFO] [stdout]      |
[INFO] [stdout] 1553 | /     r#"
[INFO] [stdout] 1554 | |     def foo : I64 := 1
[INFO] [stdout] 1555 | |     def bar : I64 := 2
[INFO] [stdout] 1556 | |     "#
[INFO] [stdout] 1557 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1556 -     "#
[INFO] [stdout] 1557 -     .into(),
[INFO] [stdout] 1556 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1553 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1554 |     def foo : I64 := 1
[INFO] [stdout] 1555 |     def bar : I64 := 2
[INFO] [stdout] 1556 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1605:5
[INFO] [stdout]      |
[INFO] [stdout] 1605 | /     r#"
[INFO] [stdout] 1606 | |     def foo : I64 := 1
[INFO] [stdout] 1607 | |     "#
[INFO] [stdout] 1608 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1607 -     "#
[INFO] [stdout] 1608 -     .into(),
[INFO] [stdout] 1607 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1605 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1606 |     def foo : I64 := 1
[INFO] [stdout] 1607 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1633:31
[INFO] [stdout]      |
[INFO] [stdout] 1633 |     let parsed_b = parse_file(spelling.as_str().into()).unwrap();
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1633 -     let parsed_b = parse_file(spelling.as_str().into()).unwrap();
[INFO] [stdout] 1633 +     let parsed_b = parse_file(spelling.as_str()).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1633 -     let parsed_b = parse_file(spelling.as_str().into()).unwrap();
[INFO] [stdout] 1633 +     let parsed_b = parse_file(<&str as Into<_>>::into(spelling.as_str())).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1660:5
[INFO] [stdout]      |
[INFO] [stdout] 1660 | /     r#"
[INFO] [stdout] 1661 | |     def read : I64 := 1
[INFO] [stdout] 1662 | |     def write : I64 := 2
[INFO] [stdout] 1663 | |     "#
[INFO] [stdout] 1664 | |     .into(),
[INFO] [stdout]      | |___________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1663 -     "#
[INFO] [stdout] 1664 -     .into(),
[INFO] [stdout] 1663 +     "#,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1660 ~     <&str as Into<_>>::into(r#"
[INFO] [stdout] 1661 |     def read : I64 := 1
[INFO] [stdout] 1662 |     def write : I64 := 2
[INFO] [stdout] 1663 ~     "#),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1680:31
[INFO] [stdout]      |
[INFO] [stdout] 1680 |   let parsed_top = parse_file("def marker : I64 := 0".into()).unwrap();
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1680 -   let parsed_top = parse_file("def marker : I64 := 0".into()).unwrap();
[INFO] [stdout] 1680 +   let parsed_top = parse_file("def marker : I64 := 0").unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1680 -   let parsed_top = parse_file("def marker : I64 := 0".into()).unwrap();
[INFO] [stdout] 1680 +   let parsed_top = parse_file(<&str as Into<_>>::into("def marker : I64 := 0")).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1693:29
[INFO] [stdout]      |
[INFO] [stdout] 1693 |   let parsed_d = parse_file("use test_nest_c {sub {read}}".into()).unwrap();
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1693 -   let parsed_d = parse_file("use test_nest_c {sub {read}}".into()).unwrap();
[INFO] [stdout] 1693 +   let parsed_d = parse_file("use test_nest_c {sub {read}}").unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1693 -   let parsed_d = parse_file("use test_nest_c {sub {read}}".into()).unwrap();
[INFO] [stdout] 1693 +   let parsed_d = parse_file(<&str as Into<_>>::into("use test_nest_c {sub {read}}")).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> core/src/term/module/test.rs:1715:27
[INFO] [stdout]      |
[INFO] [stdout] 1715 |   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout]      |                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1715 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 1715 +   let parsed = parse_file(source).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1715 -   let parsed = parse_file(source.into()).unwrap();
[INFO] [stdout] 1715 +   let parsed = parse_file(<&str as Into<_>>::into(source)).unwrap();
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `monad-core` (lib test) due to 93 previous errors
[INFO] [stderr] warning: unused dependency `console_error_panic_hook`
[INFO] [stderr]   --> core/Cargo.toml:17:1
[INFO] [stderr]    |
[INFO] [stderr] 17 | console_error_panic_hook = { version = "0.1", optional = true }
[INFO] [stderr]    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `console_error_panic_hook`
[INFO] [stderr] warning: unused dependency `paste`
[INFO] [stderr]   --> core/Cargo.toml:10:1
[INFO] [stderr]    |
[INFO] [stderr] 10 | paste.workspace = true
[INFO] [stderr]    | ^^^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the dependency on `paste`
[INFO] [stderr] warning: `monad-core` (manifest) generated 2 warnings
[INFO] [stderr] warning: unused dependency `serde-wasm-bindgen`
[INFO] [stderr]   --> wasm/Cargo.toml:20:1
[INFO] [stderr]    |
[INFO] [stderr] 20 | serde-wasm-bindgen = "0.6"
[INFO] [stderr]    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `serde-wasm-bindgen`
[INFO] [stderr] warning: `monad-wasm` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb", kill_on_drop: false }`
[INFO] [stdout] 9f1ed8f5eb471ea95f3ccfd0734ff206b3c0072a1510d5c04a2142e95dda29eb
