[INFO] fetching crate bye_pcd_rs 0.12.1...
[INFO] checking bye_pcd_rs-0.12.1 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate bye_pcd_rs 0.12.1 into /workspace/builds/worker-1-tc2/source
[INFO] started tweaking crates.io crate bye_pcd_rs 0.12.1
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate bye_pcd_rs 0.12.1
[INFO] tweaked toml for crates.io crate bye_pcd_rs 0.12.1 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate bye_pcd_rs 0.12.1 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate bye_pcd_rs 0.12.1 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: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:71:12
[INFO] [stderr]    |
[INFO] [stderr] 71 | homepage = "https://github.com/qsbye/bye.pcd.rs"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 75 | repository = "https://github.com/qsbye/bye.pcd.rs"
[INFO] [stderr]    |              -------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bye_pcd_rs` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-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] 9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd
[INFO] running `Command { std: "docker" "start" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd", 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" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd", 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" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:71:12
[INFO] [stderr]    |
[INFO] [stderr] 71 | homepage = "https://github.com/qsbye/bye.pcd.rs"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 75 | repository = "https://github.com/qsbye/bye.pcd.rs"
[INFO] [stderr]    |              -------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bye_pcd_rs` (manifest) generated 1 warning
[INFO] [stderr]    Compiling proc-macro2 v1.0.93
[INFO] [stderr]    Compiling unicode-ident v1.0.16
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]    Compiling memchr v2.7.4
[INFO] [stderr]    Compiling regex-syntax v0.8.5
[INFO] [stderr]    Compiling autocfg v1.4.0
[INFO] [stderr]    Compiling thiserror v2.0.11
[INFO] [stderr]    Compiling either v1.13.0
[INFO] [stderr]    Compiling once_cell v1.20.3
[INFO] [stderr]    Compiling eyre v0.6.12
[INFO] [stderr]     Checking indenter v0.3.3
[INFO] [stderr]     Checking byteorder v1.5.0
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]     Checking aho-corasick v1.1.3
[INFO] [stderr]    Compiling quote v1.0.38
[INFO] [stderr]    Compiling syn v2.0.98
[INFO] [stderr]     Checking regex-automata v0.4.9
[INFO] [stderr]    Compiling unzip-n v0.1.2
[INFO] [stderr]    Compiling thiserror-impl v2.0.11
[INFO] [stderr]     Checking regex v1.11.1
[INFO] [stderr]    Compiling bye_pcd_derive_rs v0.12.0
[INFO] [stderr]     Checking bye_pcd_rs v0.12.1 (/opt/rustwide/workdir)
[INFO] [stdout] warning: use of deprecated associated function `core::num::<impl usize>::max_value`: replaced by the `MAX` associated constant on this type
[INFO] [stdout]    --> src/writer.rs:185:44
[INFO] [stdout]     |
[INFO] [stdout] 185 |             let points_arg_width = (usize::max_value() as f64).log10().floor() as usize + 1;
[INFO] [stdout]     |                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(deprecated)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::num::<impl usize>::max_value`: replaced by the `MAX` associated constant on this type
[INFO] [stdout]    --> src/writer.rs:185:44
[INFO] [stdout]     |
[INFO] [stdout] 185 |             let points_arg_width = (usize::max_value() as f64).log10().floor() as usize + 1;
[INFO] [stdout]     |                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(deprecated)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:16:28
[INFO] [stdout]    |
[INFO] [stdout] 16 |                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 16 -                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout] 16 +                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 16 -                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout] 16 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "Unexpected end of file")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:32:28
[INFO] [stdout]    |
[INFO] [stdout] 32 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 32 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 32 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:42:28
[INFO] [stdout]    |
[INFO] [stdout] 42 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 42 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 42 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:60:32
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 60 +                     return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 60 +                     return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:65:17
[INFO] [stdout]    |
[INFO] [stdout] 65 |                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 65 -                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout] 65 +                 Error::new_parse_error(*line_count, "VERSION line is not understood"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 -                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout] 65 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "VERSION line is not understood")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 |                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout] 74 +                 Error::new_parse_error(*line_count, "FIELDS line is not understood"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout] 74 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "FIELDS line is not understood")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:91:28
[INFO] [stdout]    |
[INFO] [stdout] 91 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 91 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 91 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 91 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:104:24
[INFO] [stdout]     |
[INFO] [stdout] 104 |             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 104 -             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout] 104 +             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 -             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout] 104 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "SIZE line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:120:24
[INFO] [stdout]     |
[INFO] [stdout] 120 |             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout] 120 +             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout] 120 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "TYPE line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:131:32
[INFO] [stdout]     |
[INFO] [stdout] 131 |                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]     |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 131 +                     return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 131 +                     return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:144:24
[INFO] [stdout]     |
[INFO] [stdout] 144 |             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 144 -             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout] 144 +             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 144 -             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout] 144 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "COUNT line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:160:24
[INFO] [stdout]     |
[INFO] [stdout] 160 |             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout] 160 +             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout] 160 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "WIDTH line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:171:17
[INFO] [stdout]     |
[INFO] [stdout] 171 |                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout] 171 +                 Error::new_parse_error(*line_count, "HEIGHT line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout] 171 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "HEIGHT line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:184:17
[INFO] [stdout]     |
[INFO] [stdout] 184 |                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 184 -                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout] 184 +                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 -                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout] 184 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "VIEWPOINT line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:211:17
[INFO] [stdout]     |
[INFO] [stdout] 211 |                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout] 211 +                 Error::new_parse_error(*line_count, "POINTS line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout] 211 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "POINTS line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:223:24
[INFO] [stdout]     |
[INFO] [stdout] 223 |             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout] 223 +             return Err(Error::new_parse_error(*line_count, "DATA line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout] 223 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "DATA line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:231:21
[INFO] [stdout]     |
[INFO] [stdout] 231 |                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 231 -                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout] 231 +                     Error::new_parse_error(*line_count, "DATA line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 -                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout] 231 +                     <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "DATA line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:240:13
[INFO] [stdout]     |
[INFO] [stdout] 240 |             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 240 -             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 240 +             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 -             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 240 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:246:13
[INFO] [stdout]     |
[INFO] [stdout] 246 |             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 246 -             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 246 +             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 246 -             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 246 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:252:13
[INFO] [stdout]     |
[INFO] [stdout] 252 |             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout] 252 +             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 -             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout] 252 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:276:36
[INFO] [stdout]     |
[INFO] [stdout] 276 |                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 276 -                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 276 +                         return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 -                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 276 +                         return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `bye_pcd_rs` (lib) due to 21 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:16:28
[INFO] [stdout]    |
[INFO] [stdout] 16 |                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 16 -                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout] 16 +                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file"));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 16 -                 return Err(Error::new_parse_error(*line_count, "Unexpected end of file").into());
[INFO] [stdout] 16 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "Unexpected end of file")));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:32:28
[INFO] [stdout]    |
[INFO] [stdout] 32 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 32 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 32 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:42:28
[INFO] [stdout]    |
[INFO] [stdout] 42 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 42 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 42 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:60:32
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 60 +                     return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 60 +                     return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:65:17
[INFO] [stdout]    |
[INFO] [stdout] 65 |                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 65 -                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout] 65 +                 Error::new_parse_error(*line_count, "VERSION line is not understood"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 -                 Error::new_parse_error(*line_count, "VERSION line is not understood").into(),
[INFO] [stdout] 65 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "VERSION line is not understood")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 |                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout] 74 +                 Error::new_parse_error(*line_count, "FIELDS line is not understood"),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 Error::new_parse_error(*line_count, "FIELDS line is not understood").into(),
[INFO] [stdout] 74 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "FIELDS line is not understood")),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/utils.rs:91:28
[INFO] [stdout]    |
[INFO] [stdout] 91 |                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 91 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 91 +                 return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 -                 return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 91 +                 return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:104:24
[INFO] [stdout]     |
[INFO] [stdout] 104 |             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 104 -             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout] 104 +             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 -             return Err(Error::new_parse_error(*line_count, "SIZE line is not understood").into());
[INFO] [stdout] 104 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "SIZE line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:120:24
[INFO] [stdout]     |
[INFO] [stdout] 120 |             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout] 120 +             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -             return Err(Error::new_parse_error(*line_count, "TYPE line is not understood").into());
[INFO] [stdout] 120 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "TYPE line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:131:32
[INFO] [stdout]     |
[INFO] [stdout] 131 |                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]     |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 131 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 131 +                     return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 -                     return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 131 +                     return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:144:24
[INFO] [stdout]     |
[INFO] [stdout] 144 |             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 144 -             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout] 144 +             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 144 -             return Err(Error::new_parse_error(*line_count, "COUNT line is not understood").into());
[INFO] [stdout] 144 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "COUNT line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:160:24
[INFO] [stdout]     |
[INFO] [stdout] 160 |             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout] 160 +             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -             return Err(Error::new_parse_error(*line_count, "WIDTH line is not understood").into());
[INFO] [stdout] 160 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "WIDTH line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:171:17
[INFO] [stdout]     |
[INFO] [stdout] 171 |                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout] 171 +                 Error::new_parse_error(*line_count, "HEIGHT line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 Error::new_parse_error(*line_count, "HEIGHT line is not understood").into(),
[INFO] [stdout] 171 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "HEIGHT line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:184:17
[INFO] [stdout]     |
[INFO] [stdout] 184 |                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 184 -                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout] 184 +                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 -                 Error::new_parse_error(*line_count, "VIEWPOINT line is not understood").into(),
[INFO] [stdout] 184 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "VIEWPOINT line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:211:17
[INFO] [stdout]     |
[INFO] [stdout] 211 |                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout] 211 +                 Error::new_parse_error(*line_count, "POINTS line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -                 Error::new_parse_error(*line_count, "POINTS line is not understood").into(),
[INFO] [stdout] 211 +                 <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "POINTS line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:223:24
[INFO] [stdout]     |
[INFO] [stdout] 223 |             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout] 223 +             return Err(Error::new_parse_error(*line_count, "DATA line is not understood"));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -             return Err(Error::new_parse_error(*line_count, "DATA line is not understood").into());
[INFO] [stdout] 223 +             return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "DATA line is not understood")));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:231:21
[INFO] [stdout]     |
[INFO] [stdout] 231 |                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 231 -                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout] 231 +                     Error::new_parse_error(*line_count, "DATA line is not understood"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 -                     Error::new_parse_error(*line_count, "DATA line is not understood").into(),
[INFO] [stdout] 231 +                     <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "DATA line is not understood")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:240:13
[INFO] [stdout]     |
[INFO] [stdout] 240 |             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 240 -             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 240 +             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 -             Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 240 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "SIZE entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:246:13
[INFO] [stdout]     |
[INFO] [stdout] 246 |             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 246 -             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 246 +             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 246 -             Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry").into(),
[INFO] [stdout] 246 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "TYPE entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:252:13
[INFO] [stdout]     |
[INFO] [stdout] 252 |             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout] 252 +             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 -             Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry").into(),
[INFO] [stdout] 252 +             <error::Error as Into<_>>::into(Error::new_parse_error(*line_count, "COUNT entry conflicts with FIELD entry")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/utils.rs:276:36
[INFO] [stdout]     |
[INFO] [stdout] 276 |                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 276 -                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 276 +                         return Err(Error::new_parse_error(*line_count, &desc));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 -                         return Err(Error::new_parse_error(*line_count, &desc).into());
[INFO] [stdout] 276 +                         return Err(<error::Error as Into<_>>::into(Error::new_parse_error(*line_count, &desc)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `bye_pcd_rs` (lib test) due to 21 previous errors; 1 warning emitted
[INFO] [stderr] warning: unused dependency `regex`
[INFO] [stderr]   --> Cargo.toml:17:15
[INFO] [stderr]    |
[INFO] [stderr] 17 | [dependencies.regex]
[INFO] [stderr]    |               ^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `regex`
[INFO] [stderr] warning: `bye_pcd_rs` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd", kill_on_drop: false }`
[INFO] [stdout] 9a0c40bf9b0c806af48cdcff9127baf71478e7a2bacca867c0a9d15b84c136bd
