[INFO] fetching crate opentelemetry-micropb 0.2.1...
[INFO] checking opentelemetry-micropb-0.2.1 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate opentelemetry-micropb 0.2.1 into /workspace/builds/worker-4-tc2/source
[INFO] removed /workspace/builds/worker-4-tc2/source/.cargo/config.toml
[INFO] started tweaking crates.io crate opentelemetry-micropb 0.2.1
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate opentelemetry-micropb 0.2.1
[INFO] tweaked toml for crates.io crate opentelemetry-micropb 0.2.1 written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate opentelemetry-micropb 0.2.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 opentelemetry-micropb 0.2.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] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-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] 3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b
[INFO] running `Command { std: "docker" "start" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b", 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" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b", 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" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking mio v1.2.0
[INFO] [stderr]    Compiling anyhow v1.0.102
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling itertools v0.14.0
[INFO] [stderr]     Checking axum-core v0.5.6
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]     Checking rand v0.9.2
[INFO] [stderr]     Checking const-hex v1.18.1
[INFO] [stderr]     Checking micropb v0.6.0
[INFO] [stderr]     Checking opentelemetry-micropb v0.2.1 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:666:38
[INFO] [stdout]     |
[INFO] [stdout] 666 |                         self.r#key = value.into();
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 666 -                         self.r#key = value.into();
[INFO] [stdout] 666 +                         self.r#key = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 666 -                         self.r#key = value.into();
[INFO] [stdout] 666 +                         self.r#key = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:672:38
[INFO] [stdout]     |
[INFO] [stdout] 672 |                         self.r#key = value.into();
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 672 -                         self.r#key = value.into();
[INFO] [stdout] 672 +                         self.r#key = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 672 -                         self.r#key = value.into();
[INFO] [stdout] 672 +                         self.r#key = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AnyValue`
[INFO] [stdout]    --> src/generated_std.rs:684:40
[INFO] [stdout]     |
[INFO] [stdout] 684 |                         self.r#value = value.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 684 -                         self.r#value = value.into();
[INFO] [stdout] 684 +                         self.r#value = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 -                         self.r#value = value.into();
[INFO] [stdout] 684 +                         self.r#value = <AnyValue as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]    --> src/generated_std.rs:729:47
[INFO] [stdout]     |
[INFO] [stdout] 729 |                         self.r#key_strindex = value.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 729 -                         self.r#key_strindex = value.into();
[INFO] [stdout] 729 +                         self.r#key_strindex = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 -                         self.r#key_strindex = value.into();
[INFO] [stdout] 729 +                         self.r#key_strindex = <i32 as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]    --> src/generated_std.rs:735:47
[INFO] [stdout]     |
[INFO] [stdout] 735 |                         self.r#key_strindex = value.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 735 -                         self.r#key_strindex = value.into();
[INFO] [stdout] 735 +                         self.r#key_strindex = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 735 -                         self.r#key_strindex = value.into();
[INFO] [stdout] 735 +                         self.r#key_strindex = <i32 as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:957:39
[INFO] [stdout]     |
[INFO] [stdout] 957 |                         self.r#name = value.into();
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 957 -                         self.r#name = value.into();
[INFO] [stdout] 957 +                         self.r#name = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 957 -                         self.r#name = value.into();
[INFO] [stdout] 957 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:963:39
[INFO] [stdout]     |
[INFO] [stdout] 963 |                         self.r#name = value.into();
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 963 -                         self.r#name = value.into();
[INFO] [stdout] 963 +                         self.r#name = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 963 -                         self.r#name = value.into();
[INFO] [stdout] 963 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:982:42
[INFO] [stdout]     |
[INFO] [stdout] 982 |                         self.r#version = value.into();
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 982 -                         self.r#version = value.into();
[INFO] [stdout] 982 +                         self.r#version = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 -                         self.r#version = value.into();
[INFO] [stdout] 982 +                         self.r#version = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/generated_std.rs:988:42
[INFO] [stdout]     |
[INFO] [stdout] 988 |                         self.r#version = value.into();
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 988 -                         self.r#version = value.into();
[INFO] [stdout] 988 +                         self.r#version = value;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 988 -                         self.r#version = value.into();
[INFO] [stdout] 988 +                         self.r#version = <String as Into<_>>::into(value);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:1007:59
[INFO] [stdout]      |
[INFO] [stdout] 1007 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1007 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1007 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1007 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1007 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:1013:59
[INFO] [stdout]      |
[INFO] [stdout] 1013 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1013 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1013 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1013 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1013 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1246:45
[INFO] [stdout]      |
[INFO] [stdout] 1246 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1246 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1246 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1246 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1246 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1255:45
[INFO] [stdout]      |
[INFO] [stdout] 1255 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1255 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1255 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1255 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1255 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1274:39
[INFO] [stdout]      |
[INFO] [stdout] 1274 |                         self.r#type = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1274 -                         self.r#type = value.into();
[INFO] [stdout] 1274 +                         self.r#type = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1274 -                         self.r#type = value.into();
[INFO] [stdout] 1274 +                         self.r#type = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1280:39
[INFO] [stdout]      |
[INFO] [stdout] 1280 |                         self.r#type = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1280 -                         self.r#type = value.into();
[INFO] [stdout] 1280 +                         self.r#type = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1280 -                         self.r#type = value.into();
[INFO] [stdout] 1280 +                         self.r#type = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:1521:59
[INFO] [stdout]      |
[INFO] [stdout] 1521 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1521 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1521 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1521 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1521 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:1527:59
[INFO] [stdout]      |
[INFO] [stdout] 1527 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1527 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1527 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1527 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 1527 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Resource`
[INFO] [stdout]     --> src/generated_std.rs:1834:43
[INFO] [stdout]      |
[INFO] [stdout] 1834 |                         self.r#resource = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1834 -                         self.r#resource = value.into();
[INFO] [stdout] 1834 +                         self.r#resource = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1834 -                         self.r#resource = value.into();
[INFO] [stdout] 1834 +                         self.r#resource = <Resource as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1889:45
[INFO] [stdout]      |
[INFO] [stdout] 1889 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1889 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1889 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1889 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1889 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:1898:45
[INFO] [stdout]      |
[INFO] [stdout] 1898 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1898 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         self.r#schema_url = value.into();
[INFO] [stdout] 1898 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `InstrumentationScope`
[INFO] [stdout]     --> src/generated_std.rs:2140:40
[INFO] [stdout]      |
[INFO] [stdout] 2140 |                         self.r#scope = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2140 -                         self.r#scope = value.into();
[INFO] [stdout] 2140 +                         self.r#scope = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2140 -                         self.r#scope = value.into();
[INFO] [stdout] 2140 +                         self.r#scope = <InstrumentationScope as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2197:45
[INFO] [stdout]      |
[INFO] [stdout] 2197 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2197 -                         self.r#schema_url = value.into();
[INFO] [stdout] 2197 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2197 -                         self.r#schema_url = value.into();
[INFO] [stdout] 2197 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2206:45
[INFO] [stdout]      |
[INFO] [stdout] 2206 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2206 -                         self.r#schema_url = value.into();
[INFO] [stdout] 2206 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2206 -                         self.r#schema_url = value.into();
[INFO] [stdout] 2206 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:2523:49
[INFO] [stdout]      |
[INFO] [stdout] 2523 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2523 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 2523 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2523 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 2523 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:2529:49
[INFO] [stdout]      |
[INFO] [stdout] 2529 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2529 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 2529 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2529 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 2529 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:2548:58
[INFO] [stdout]      |
[INFO] [stdout] 2548 |                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2548 -                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout] 2548 +                         self.r#observed_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2548 -                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout] 2548 +                         self.r#observed_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:2554:58
[INFO] [stdout]      |
[INFO] [stdout] 2554 |                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2554 -                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout] 2554 +                         self.r#observed_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2554 -                         self.r#observed_time_unix_nano = value.into();
[INFO] [stdout] 2554 +                         self.r#observed_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SeverityNumber`
[INFO] [stdout]     --> src/generated_std.rs:2573:50
[INFO] [stdout]      |
[INFO] [stdout] 2573 |                         self.r#severity_number = value.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2573 -                         self.r#severity_number = value.into();
[INFO] [stdout] 2573 +                         self.r#severity_number = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2573 -                         self.r#severity_number = value.into();
[INFO] [stdout] 2573 +                         self.r#severity_number = <SeverityNumber as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SeverityNumber`
[INFO] [stdout]     --> src/generated_std.rs:2582:50
[INFO] [stdout]      |
[INFO] [stdout] 2582 |                         self.r#severity_number = value.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2582 -                         self.r#severity_number = value.into();
[INFO] [stdout] 2582 +                         self.r#severity_number = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2582 -                         self.r#severity_number = value.into();
[INFO] [stdout] 2582 +                         self.r#severity_number = <SeverityNumber as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2601:48
[INFO] [stdout]      |
[INFO] [stdout] 2601 |                         self.r#severity_text = value.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2601 -                         self.r#severity_text = value.into();
[INFO] [stdout] 2601 +                         self.r#severity_text = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2601 -                         self.r#severity_text = value.into();
[INFO] [stdout] 2601 +                         self.r#severity_text = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2610:48
[INFO] [stdout]      |
[INFO] [stdout] 2610 |                         self.r#severity_text = value.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2610 -                         self.r#severity_text = value.into();
[INFO] [stdout] 2610 +                         self.r#severity_text = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2610 -                         self.r#severity_text = value.into();
[INFO] [stdout] 2610 +                         self.r#severity_text = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AnyValue`
[INFO] [stdout]     --> src/generated_std.rs:2627:39
[INFO] [stdout]      |
[INFO] [stdout] 2627 |                         self.r#body = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2627 -                         self.r#body = value.into();
[INFO] [stdout] 2627 +                         self.r#body = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2627 -                         self.r#body = value.into();
[INFO] [stdout] 2627 +                         self.r#body = <AnyValue as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:2682:59
[INFO] [stdout]      |
[INFO] [stdout] 2682 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2682 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 2682 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2682 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 2682 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:2688:59
[INFO] [stdout]      |
[INFO] [stdout] 2688 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2688 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 2688 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2688 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 2688 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:2704:40
[INFO] [stdout]      |
[INFO] [stdout] 2704 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2704 -                         self.r#flags = value.into();
[INFO] [stdout] 2704 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2704 -                         self.r#flags = value.into();
[INFO] [stdout] 2704 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:2710:40
[INFO] [stdout]      |
[INFO] [stdout] 2710 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2710 -                         self.r#flags = value.into();
[INFO] [stdout] 2710 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2710 -                         self.r#flags = value.into();
[INFO] [stdout] 2710 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/generated_std.rs:2729:43
[INFO] [stdout]      |
[INFO] [stdout] 2729 |                         self.r#trace_id = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2729 -                         self.r#trace_id = value.into();
[INFO] [stdout] 2729 +                         self.r#trace_id = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2729 -                         self.r#trace_id = value.into();
[INFO] [stdout] 2729 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/generated_std.rs:2735:43
[INFO] [stdout]      |
[INFO] [stdout] 2735 |                         self.r#trace_id = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2735 -                         self.r#trace_id = value.into();
[INFO] [stdout] 2735 +                         self.r#trace_id = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2735 -                         self.r#trace_id = value.into();
[INFO] [stdout] 2735 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/generated_std.rs:2754:42
[INFO] [stdout]      |
[INFO] [stdout] 2754 |                         self.r#span_id = value.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2754 -                         self.r#span_id = value.into();
[INFO] [stdout] 2754 +                         self.r#span_id = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2754 -                         self.r#span_id = value.into();
[INFO] [stdout] 2754 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/generated_std.rs:2760:42
[INFO] [stdout]      |
[INFO] [stdout] 2760 |                         self.r#span_id = value.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2760 -                         self.r#span_id = value.into();
[INFO] [stdout] 2760 +                         self.r#span_id = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2760 -                         self.r#span_id = value.into();
[INFO] [stdout] 2760 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2779:45
[INFO] [stdout]      |
[INFO] [stdout] 2779 |                         self.r#event_name = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2779 -                         self.r#event_name = value.into();
[INFO] [stdout] 2779 +                         self.r#event_name = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2779 -                         self.r#event_name = value.into();
[INFO] [stdout] 2779 +                         self.r#event_name = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:2788:45
[INFO] [stdout]      |
[INFO] [stdout] 2788 |                         self.r#event_name = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2788 -                         self.r#event_name = value.into();
[INFO] [stdout] 2788 +                         self.r#event_name = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2788 -                         self.r#event_name = value.into();
[INFO] [stdout] 2788 +                         self.r#event_name = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ExportLogsPartialSuccess`
[INFO] [stdout]     --> src/generated_std.rs:3476:54
[INFO] [stdout]      |
[INFO] [stdout] 3476 | ...                   self.r#partial_success = value.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3476 -                             self.r#partial_success = value.into();
[INFO] [stdout] 3476 +                             self.r#partial_success = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3476 -                             self.r#partial_success = value.into();
[INFO] [stdout] 3476 +                             self.r#partial_success = <ExportLogsPartialSuccess as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:3669:59
[INFO] [stdout]      |
[INFO] [stdout] 3669 | ...                   self.r#rejected_log_records = value.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3669 -                             self.r#rejected_log_records = value.into();
[INFO] [stdout] 3669 +                             self.r#rejected_log_records = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3669 -                             self.r#rejected_log_records = value.into();
[INFO] [stdout] 3669 +                             self.r#rejected_log_records = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:3675:59
[INFO] [stdout]      |
[INFO] [stdout] 3675 | ...                   self.r#rejected_log_records = value.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3675 -                             self.r#rejected_log_records = value.into();
[INFO] [stdout] 3675 +                             self.r#rejected_log_records = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3675 -                             self.r#rejected_log_records = value.into();
[INFO] [stdout] 3675 +                             self.r#rejected_log_records = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:3696:52
[INFO] [stdout]      |
[INFO] [stdout] 3696 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3696 -                             self.r#error_message = value.into();
[INFO] [stdout] 3696 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3696 -                             self.r#error_message = value.into();
[INFO] [stdout] 3696 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:3705:52
[INFO] [stdout]      |
[INFO] [stdout] 3705 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3705 -                             self.r#error_message = value.into();
[INFO] [stdout] 3705 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3705 -                             self.r#error_message = value.into();
[INFO] [stdout] 3705 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ExportMetricsPartialSuccess`
[INFO] [stdout]     --> src/generated_std.rs:3976:54
[INFO] [stdout]      |
[INFO] [stdout] 3976 | ...                   self.r#partial_success = value.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3976 -                             self.r#partial_success = value.into();
[INFO] [stdout] 3976 +                             self.r#partial_success = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3976 -                             self.r#partial_success = value.into();
[INFO] [stdout] 3976 +                             self.r#partial_success = <ExportMetricsPartialSuccess as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:4169:59
[INFO] [stdout]      |
[INFO] [stdout] 4169 | ...                   self.r#rejected_data_points = value.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4169 -                             self.r#rejected_data_points = value.into();
[INFO] [stdout] 4169 +                             self.r#rejected_data_points = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4169 -                             self.r#rejected_data_points = value.into();
[INFO] [stdout] 4169 +                             self.r#rejected_data_points = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:4175:59
[INFO] [stdout]      |
[INFO] [stdout] 4175 | ...                   self.r#rejected_data_points = value.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4175 -                             self.r#rejected_data_points = value.into();
[INFO] [stdout] 4175 +                             self.r#rejected_data_points = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4175 -                             self.r#rejected_data_points = value.into();
[INFO] [stdout] 4175 +                             self.r#rejected_data_points = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:4196:52
[INFO] [stdout]      |
[INFO] [stdout] 4196 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4196 -                             self.r#error_message = value.into();
[INFO] [stdout] 4196 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4196 -                             self.r#error_message = value.into();
[INFO] [stdout] 4196 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:4205:52
[INFO] [stdout]      |
[INFO] [stdout] 4205 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4205 -                             self.r#error_message = value.into();
[INFO] [stdout] 4205 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4205 -                             self.r#error_message = value.into();
[INFO] [stdout] 4205 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `ExportTracePartialSuccess`
[INFO] [stdout]     --> src/generated_std.rs:4470:54
[INFO] [stdout]      |
[INFO] [stdout] 4470 | ...                   self.r#partial_success = value.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4470 -                             self.r#partial_success = value.into();
[INFO] [stdout] 4470 +                             self.r#partial_success = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4470 -                             self.r#partial_success = value.into();
[INFO] [stdout] 4470 +                             self.r#partial_success = <ExportTracePartialSuccess as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:4660:53
[INFO] [stdout]      |
[INFO] [stdout] 4660 | ...                   self.r#rejected_spans = value.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4660 -                             self.r#rejected_spans = value.into();
[INFO] [stdout] 4660 +                             self.r#rejected_spans = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4660 -                             self.r#rejected_spans = value.into();
[INFO] [stdout] 4660 +                             self.r#rejected_spans = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]     --> src/generated_std.rs:4666:53
[INFO] [stdout]      |
[INFO] [stdout] 4666 | ...                   self.r#rejected_spans = value.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4666 -                             self.r#rejected_spans = value.into();
[INFO] [stdout] 4666 +                             self.r#rejected_spans = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4666 -                             self.r#rejected_spans = value.into();
[INFO] [stdout] 4666 +                             self.r#rejected_spans = <i64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:4687:52
[INFO] [stdout]      |
[INFO] [stdout] 4687 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4687 -                             self.r#error_message = value.into();
[INFO] [stdout] 4687 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4687 -                             self.r#error_message = value.into();
[INFO] [stdout] 4687 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:4696:52
[INFO] [stdout]      |
[INFO] [stdout] 4696 | ...                   self.r#error_message = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4696 -                             self.r#error_message = value.into();
[INFO] [stdout] 4696 +                             self.r#error_message = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4696 -                             self.r#error_message = value.into();
[INFO] [stdout] 4696 +                             self.r#error_message = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Resource`
[INFO] [stdout]     --> src/generated_std.rs:4987:43
[INFO] [stdout]      |
[INFO] [stdout] 4987 |                         self.r#resource = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4987 -                         self.r#resource = value.into();
[INFO] [stdout] 4987 +                         self.r#resource = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4987 -                         self.r#resource = value.into();
[INFO] [stdout] 4987 +                         self.r#resource = <Resource as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5042:45
[INFO] [stdout]      |
[INFO] [stdout] 5042 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5042 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5042 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5042 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5042 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5051:45
[INFO] [stdout]      |
[INFO] [stdout] 5051 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5051 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5051 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5051 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5051 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `InstrumentationScope`
[INFO] [stdout]     --> src/generated_std.rs:5293:40
[INFO] [stdout]      |
[INFO] [stdout] 5293 |                         self.r#scope = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5293 -                         self.r#scope = value.into();
[INFO] [stdout] 5293 +                         self.r#scope = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5293 -                         self.r#scope = value.into();
[INFO] [stdout] 5293 +                         self.r#scope = <InstrumentationScope as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5350:45
[INFO] [stdout]      |
[INFO] [stdout] 5350 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5350 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5350 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5350 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5350 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5359:45
[INFO] [stdout]      |
[INFO] [stdout] 5359 |                         self.r#schema_url = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5359 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5359 +                         self.r#schema_url = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5359 -                         self.r#schema_url = value.into();
[INFO] [stdout] 5359 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5678:39
[INFO] [stdout]      |
[INFO] [stdout] 5678 |                         self.r#name = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5678 -                         self.r#name = value.into();
[INFO] [stdout] 5678 +                         self.r#name = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5678 -                         self.r#name = value.into();
[INFO] [stdout] 5678 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5684:39
[INFO] [stdout]      |
[INFO] [stdout] 5684 |                         self.r#name = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5684 -                         self.r#name = value.into();
[INFO] [stdout] 5684 +                         self.r#name = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5684 -                         self.r#name = value.into();
[INFO] [stdout] 5684 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5703:46
[INFO] [stdout]      |
[INFO] [stdout] 5703 |                         self.r#description = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5703 -                         self.r#description = value.into();
[INFO] [stdout] 5703 +                         self.r#description = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5703 -                         self.r#description = value.into();
[INFO] [stdout] 5703 +                         self.r#description = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5712:46
[INFO] [stdout]      |
[INFO] [stdout] 5712 |                         self.r#description = value.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5712 -                         self.r#description = value.into();
[INFO] [stdout] 5712 +                         self.r#description = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5712 -                         self.r#description = value.into();
[INFO] [stdout] 5712 +                         self.r#description = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5731:39
[INFO] [stdout]      |
[INFO] [stdout] 5731 |                         self.r#unit = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5731 -                         self.r#unit = value.into();
[INFO] [stdout] 5731 +                         self.r#unit = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5731 -                         self.r#unit = value.into();
[INFO] [stdout] 5731 +                         self.r#unit = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/generated_std.rs:5737:39
[INFO] [stdout]      |
[INFO] [stdout] 5737 |                         self.r#unit = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5737 -                         self.r#unit = value.into();
[INFO] [stdout] 5737 +                         self.r#unit = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5737 -                         self.r#unit = value.into();
[INFO] [stdout] 5737 +                         self.r#unit = <String as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6301:58
[INFO] [stdout]      |
[INFO] [stdout] 6301 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6301 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6301 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6301 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6301 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6310:58
[INFO] [stdout]      |
[INFO] [stdout] 6310 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6310 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6310 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6310 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6310 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/generated_std.rs:6326:47
[INFO] [stdout]      |
[INFO] [stdout] 6326 |                         self.r#is_monotonic = value.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6326 -                         self.r#is_monotonic = value.into();
[INFO] [stdout] 6326 +                         self.r#is_monotonic = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6326 -                         self.r#is_monotonic = value.into();
[INFO] [stdout] 6326 +                         self.r#is_monotonic = <bool as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/generated_std.rs:6332:47
[INFO] [stdout]      |
[INFO] [stdout] 6332 |                         self.r#is_monotonic = value.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6332 -                         self.r#is_monotonic = value.into();
[INFO] [stdout] 6332 +                         self.r#is_monotonic = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6332 -                         self.r#is_monotonic = value.into();
[INFO] [stdout] 6332 +                         self.r#is_monotonic = <bool as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6515:58
[INFO] [stdout]      |
[INFO] [stdout] 6515 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6515 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6515 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6515 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6515 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6524:58
[INFO] [stdout]      |
[INFO] [stdout] 6524 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6524 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6524 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6524 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6524 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6674:58
[INFO] [stdout]      |
[INFO] [stdout] 6674 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6674 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6674 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6674 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6674 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `AggregationTemporality`
[INFO] [stdout]     --> src/generated_std.rs:6683:58
[INFO] [stdout]      |
[INFO] [stdout] 6683 |                         self.r#aggregation_temporality = value.into();
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6683 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6683 +                         self.r#aggregation_temporality = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6683 -                         self.r#aggregation_temporality = value.into();
[INFO] [stdout] 6683 +                         self.r#aggregation_temporality = <AggregationTemporality as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:6945:55
[INFO] [stdout]      |
[INFO] [stdout] 6945 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6945 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 6945 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6945 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 6945 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:6951:55
[INFO] [stdout]      |
[INFO] [stdout] 6951 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6951 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 6951 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6951 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 6951 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:6967:49
[INFO] [stdout]      |
[INFO] [stdout] 6967 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6967 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 6967 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6967 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 6967 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:6973:49
[INFO] [stdout]      |
[INFO] [stdout] 6973 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6973 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 6973 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6973 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 6973 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:6989:40
[INFO] [stdout]      |
[INFO] [stdout] 6989 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6989 -                         self.r#flags = value.into();
[INFO] [stdout] 6989 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6989 -                         self.r#flags = value.into();
[INFO] [stdout] 6989 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:6995:40
[INFO] [stdout]      |
[INFO] [stdout] 6995 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6995 -                         self.r#flags = value.into();
[INFO] [stdout] 6995 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6995 -                         self.r#flags = value.into();
[INFO] [stdout] 6995 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7449:55
[INFO] [stdout]      |
[INFO] [stdout] 7449 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7449 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 7449 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7449 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 7449 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7455:55
[INFO] [stdout]      |
[INFO] [stdout] 7455 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7455 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 7455 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7455 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 7455 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7471:49
[INFO] [stdout]      |
[INFO] [stdout] 7471 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7471 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 7471 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7471 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 7471 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7477:49
[INFO] [stdout]      |
[INFO] [stdout] 7477 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7477 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 7477 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7477 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 7477 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7493:40
[INFO] [stdout]      |
[INFO] [stdout] 7493 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7493 -                         self.r#count = value.into();
[INFO] [stdout] 7493 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7493 -                         self.r#count = value.into();
[INFO] [stdout] 7493 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:7499:40
[INFO] [stdout]      |
[INFO] [stdout] 7499 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7499 -                         self.r#count = value.into();
[INFO] [stdout] 7499 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7499 -                         self.r#count = value.into();
[INFO] [stdout] 7499 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:7511:38
[INFO] [stdout]      |
[INFO] [stdout] 7511 |                         self.r#sum = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7511 -                         self.r#sum = value.into();
[INFO] [stdout] 7511 +                         self.r#sum = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7511 -                         self.r#sum = value.into();
[INFO] [stdout] 7511 +                         self.r#sum = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:7554:40
[INFO] [stdout]      |
[INFO] [stdout] 7554 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7554 -                         self.r#flags = value.into();
[INFO] [stdout] 7554 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7554 -                         self.r#flags = value.into();
[INFO] [stdout] 7554 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:7560:40
[INFO] [stdout]      |
[INFO] [stdout] 7560 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7560 -                         self.r#flags = value.into();
[INFO] [stdout] 7560 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7560 -                         self.r#flags = value.into();
[INFO] [stdout] 7560 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:7572:38
[INFO] [stdout]      |
[INFO] [stdout] 7572 |                         self.r#min = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7572 -                         self.r#min = value.into();
[INFO] [stdout] 7572 +                         self.r#min = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7572 -                         self.r#min = value.into();
[INFO] [stdout] 7572 +                         self.r#min = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:7611:38
[INFO] [stdout]      |
[INFO] [stdout] 7611 |                         self.r#max = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7611 -                         self.r#max = value.into();
[INFO] [stdout] 7611 +                         self.r#max = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7611 -                         self.r#max = value.into();
[INFO] [stdout] 7611 +                         self.r#max = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8285:55
[INFO] [stdout]      |
[INFO] [stdout] 8285 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8285 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 8285 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8285 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 8285 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8291:55
[INFO] [stdout]      |
[INFO] [stdout] 8291 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8291 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 8291 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8291 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 8291 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8307:49
[INFO] [stdout]      |
[INFO] [stdout] 8307 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8307 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 8307 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8307 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 8307 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8313:49
[INFO] [stdout]      |
[INFO] [stdout] 8313 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8313 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 8313 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8313 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 8313 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8329:40
[INFO] [stdout]      |
[INFO] [stdout] 8329 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8329 -                         self.r#count = value.into();
[INFO] [stdout] 8329 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8329 -                         self.r#count = value.into();
[INFO] [stdout] 8329 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8335:40
[INFO] [stdout]      |
[INFO] [stdout] 8335 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8335 -                         self.r#count = value.into();
[INFO] [stdout] 8335 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8335 -                         self.r#count = value.into();
[INFO] [stdout] 8335 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:8347:38
[INFO] [stdout]      |
[INFO] [stdout] 8347 |                         self.r#sum = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8347 -                         self.r#sum = value.into();
[INFO] [stdout] 8347 +                         self.r#sum = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8347 -                         self.r#sum = value.into();
[INFO] [stdout] 8347 +                         self.r#sum = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/generated_std.rs:8390:40
[INFO] [stdout]      |
[INFO] [stdout] 8390 |                         self.r#scale = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8390 -                         self.r#scale = value.into();
[INFO] [stdout] 8390 +                         self.r#scale = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8390 -                         self.r#scale = value.into();
[INFO] [stdout] 8390 +                         self.r#scale = <i32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/generated_std.rs:8396:40
[INFO] [stdout]      |
[INFO] [stdout] 8396 |                         self.r#scale = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8396 -                         self.r#scale = value.into();
[INFO] [stdout] 8396 +                         self.r#scale = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8396 -                         self.r#scale = value.into();
[INFO] [stdout] 8396 +                         self.r#scale = <i32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8412:45
[INFO] [stdout]      |
[INFO] [stdout] 8412 |                         self.r#zero_count = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8412 -                         self.r#zero_count = value.into();
[INFO] [stdout] 8412 +                         self.r#zero_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8412 -                         self.r#zero_count = value.into();
[INFO] [stdout] 8412 +                         self.r#zero_count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:8418:45
[INFO] [stdout]      |
[INFO] [stdout] 8418 |                         self.r#zero_count = value.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8418 -                         self.r#zero_count = value.into();
[INFO] [stdout] 8418 +                         self.r#zero_count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8418 -                         self.r#zero_count = value.into();
[INFO] [stdout] 8418 +                         self.r#zero_count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Buckets`
[INFO] [stdout]     --> src/generated_std.rs:8437:43
[INFO] [stdout]      |
[INFO] [stdout] 8437 |                         self.r#positive = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8437 -                         self.r#positive = value.into();
[INFO] [stdout] 8437 +                         self.r#positive = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8437 -                         self.r#positive = value.into();
[INFO] [stdout] 8437 +                         self.r#positive = <Buckets as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Buckets`
[INFO] [stdout]     --> src/generated_std.rs:8494:43
[INFO] [stdout]      |
[INFO] [stdout] 8494 |                         self.r#negative = value.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8494 -                         self.r#negative = value.into();
[INFO] [stdout] 8494 +                         self.r#negative = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8494 -                         self.r#negative = value.into();
[INFO] [stdout] 8494 +                         self.r#negative = <Buckets as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:8548:40
[INFO] [stdout]      |
[INFO] [stdout] 8548 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8548 -                         self.r#flags = value.into();
[INFO] [stdout] 8548 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8548 -                         self.r#flags = value.into();
[INFO] [stdout] 8548 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:8554:40
[INFO] [stdout]      |
[INFO] [stdout] 8554 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8554 -                         self.r#flags = value.into();
[INFO] [stdout] 8554 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8554 -                         self.r#flags = value.into();
[INFO] [stdout] 8554 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:8566:38
[INFO] [stdout]      |
[INFO] [stdout] 8566 |                         self.r#min = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8566 -                         self.r#min = value.into();
[INFO] [stdout] 8566 +                         self.r#min = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8566 -                         self.r#min = value.into();
[INFO] [stdout] 8566 +                         self.r#min = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:8605:38
[INFO] [stdout]      |
[INFO] [stdout] 8605 |                         self.r#max = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8605 -                         self.r#max = value.into();
[INFO] [stdout] 8605 +                         self.r#max = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8605 -                         self.r#max = value.into();
[INFO] [stdout] 8605 +                         self.r#max = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:8648:49
[INFO] [stdout]      |
[INFO] [stdout] 8648 |                         self.r#zero_threshold = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8648 -                         self.r#zero_threshold = value.into();
[INFO] [stdout] 8648 +                         self.r#zero_threshold = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8648 -                         self.r#zero_threshold = value.into();
[INFO] [stdout] 8648 +                         self.r#zero_threshold = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:8654:49
[INFO] [stdout]      |
[INFO] [stdout] 8654 |                         self.r#zero_threshold = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8654 -                         self.r#zero_threshold = value.into();
[INFO] [stdout] 8654 +                         self.r#zero_threshold = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8654 -                         self.r#zero_threshold = value.into();
[INFO] [stdout] 8654 +                         self.r#zero_threshold = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/generated_std.rs:9213:45
[INFO] [stdout]      |
[INFO] [stdout] 9213 | ...                   self.r#offset = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9213 -                             self.r#offset = value.into();
[INFO] [stdout] 9213 +                             self.r#offset = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9213 -                             self.r#offset = value.into();
[INFO] [stdout] 9213 +                             self.r#offset = <i32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/generated_std.rs:9219:45
[INFO] [stdout]      |
[INFO] [stdout] 9219 | ...                   self.r#offset = value.into();
[INFO] [stdout]      |                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9219 -                             self.r#offset = value.into();
[INFO] [stdout] 9219 +                             self.r#offset = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9219 -                             self.r#offset = value.into();
[INFO] [stdout] 9219 +                             self.r#offset = <i32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9539:55
[INFO] [stdout]      |
[INFO] [stdout] 9539 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9539 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 9539 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9539 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 9539 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9545:55
[INFO] [stdout]      |
[INFO] [stdout] 9545 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9545 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 9545 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9545 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 9545 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9561:49
[INFO] [stdout]      |
[INFO] [stdout] 9561 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9561 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 9561 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9561 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 9561 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9567:49
[INFO] [stdout]      |
[INFO] [stdout] 9567 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9567 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 9567 +                         self.r#time_unix_nano = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9567 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 9567 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9583:40
[INFO] [stdout]      |
[INFO] [stdout] 9583 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9583 -                         self.r#count = value.into();
[INFO] [stdout] 9583 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9583 -                         self.r#count = value.into();
[INFO] [stdout] 9583 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/generated_std.rs:9589:40
[INFO] [stdout]      |
[INFO] [stdout] 9589 |                         self.r#count = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9589 -                         self.r#count = value.into();
[INFO] [stdout] 9589 +                         self.r#count = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9589 -                         self.r#count = value.into();
[INFO] [stdout] 9589 +                         self.r#count = <u64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9605:38
[INFO] [stdout]      |
[INFO] [stdout] 9605 |                         self.r#sum = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9605 -                         self.r#sum = value.into();
[INFO] [stdout] 9605 +                         self.r#sum = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9605 -                         self.r#sum = value.into();
[INFO] [stdout] 9605 +                         self.r#sum = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9611:38
[INFO] [stdout]      |
[INFO] [stdout] 9611 |                         self.r#sum = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9611 -                         self.r#sum = value.into();
[INFO] [stdout] 9611 +                         self.r#sum = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9611 -                         self.r#sum = value.into();
[INFO] [stdout] 9611 +                         self.r#sum = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:9627:40
[INFO] [stdout]      |
[INFO] [stdout] 9627 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9627 -                         self.r#flags = value.into();
[INFO] [stdout] 9627 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9627 -                         self.r#flags = value.into();
[INFO] [stdout] 9627 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/generated_std.rs:9633:40
[INFO] [stdout]      |
[INFO] [stdout] 9633 |                         self.r#flags = value.into();
[INFO] [stdout]      |                                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9633 -                         self.r#flags = value.into();
[INFO] [stdout] 9633 +                         self.r#flags = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9633 -                         self.r#flags = value.into();
[INFO] [stdout] 9633 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9959:47
[INFO] [stdout]      |
[INFO] [stdout] 9959 | ...                   self.r#quantile = value.into();
[INFO] [stdout]      |                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9959 -                             self.r#quantile = value.into();
[INFO] [stdout] 9959 +                             self.r#quantile = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9959 -                             self.r#quantile = value.into();
[INFO] [stdout] 9959 +                             self.r#quantile = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9965:47
[INFO] [stdout]      |
[INFO] [stdout] 9965 | ...                   self.r#quantile = value.into();
[INFO] [stdout]      |                                         ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9965 -                             self.r#quantile = value.into();
[INFO] [stdout] 9965 +                             self.r#quantile = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9965 -                             self.r#quantile = value.into();
[INFO] [stdout] 9965 +                             self.r#quantile = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9981:44
[INFO] [stdout]      |
[INFO] [stdout] 9981 | ...                   self.r#value = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9981 -                             self.r#value = value.into();
[INFO] [stdout] 9981 +                             self.r#value = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9981 -                             self.r#value = value.into();
[INFO] [stdout] 9981 +                             self.r#value = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/generated_std.rs:9987:44
[INFO] [stdout]      |
[INFO] [stdout] 9987 | ...                   self.r#value = value.into();
[INFO] [stdout]      |                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9987 -                             self.r#value = value.into();
[INFO] [stdout] 9987 +                             self.r#value = value;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9987 -                             self.r#value = value.into();
[INFO] [stdout] 9987 +                             self.r#value = <f64 as Into<_>>::into(value);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:10145:49
[INFO] [stdout]       |
[INFO] [stdout] 10145 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10145 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 10145 +                         self.r#time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10145 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 10145 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:10151:49
[INFO] [stdout]       |
[INFO] [stdout] 10151 |                         self.r#time_unix_nano = value.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10151 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 10151 +                         self.r#time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10151 -                         self.r#time_unix_nano = value.into();
[INFO] [stdout] 10151 +                         self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:10170:42
[INFO] [stdout]       |
[INFO] [stdout] 10170 |                         self.r#span_id = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10170 -                         self.r#span_id = value.into();
[INFO] [stdout] 10170 +                         self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10170 -                         self.r#span_id = value.into();
[INFO] [stdout] 10170 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:10176:42
[INFO] [stdout]       |
[INFO] [stdout] 10176 |                         self.r#span_id = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10176 -                         self.r#span_id = value.into();
[INFO] [stdout] 10176 +                         self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10176 -                         self.r#span_id = value.into();
[INFO] [stdout] 10176 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:10195:43
[INFO] [stdout]       |
[INFO] [stdout] 10195 |                         self.r#trace_id = value.into();
[INFO] [stdout]       |                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10195 -                         self.r#trace_id = value.into();
[INFO] [stdout] 10195 +                         self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10195 -                         self.r#trace_id = value.into();
[INFO] [stdout] 10195 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:10201:43
[INFO] [stdout]       |
[INFO] [stdout] 10201 |                         self.r#trace_id = value.into();
[INFO] [stdout]       |                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10201 -                         self.r#trace_id = value.into();
[INFO] [stdout] 10201 +                         self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10201 -                         self.r#trace_id = value.into();
[INFO] [stdout] 10201 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Resource`
[INFO] [stdout]      --> src/generated_std.rs:10764:43
[INFO] [stdout]       |
[INFO] [stdout] 10764 |                         self.r#resource = value.into();
[INFO] [stdout]       |                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10764 -                         self.r#resource = value.into();
[INFO] [stdout] 10764 +                         self.r#resource = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10764 -                         self.r#resource = value.into();
[INFO] [stdout] 10764 +                         self.r#resource = <Resource as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:10819:45
[INFO] [stdout]       |
[INFO] [stdout] 10819 |                         self.r#schema_url = value.into();
[INFO] [stdout]       |                                             ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10819 -                         self.r#schema_url = value.into();
[INFO] [stdout] 10819 +                         self.r#schema_url = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10819 -                         self.r#schema_url = value.into();
[INFO] [stdout] 10819 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:10828:45
[INFO] [stdout]       |
[INFO] [stdout] 10828 |                         self.r#schema_url = value.into();
[INFO] [stdout]       |                                             ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10828 -                         self.r#schema_url = value.into();
[INFO] [stdout] 10828 +                         self.r#schema_url = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10828 -                         self.r#schema_url = value.into();
[INFO] [stdout] 10828 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `InstrumentationScope`
[INFO] [stdout]      --> src/generated_std.rs:11070:40
[INFO] [stdout]       |
[INFO] [stdout] 11070 |                         self.r#scope = value.into();
[INFO] [stdout]       |                                        ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11070 -                         self.r#scope = value.into();
[INFO] [stdout] 11070 +                         self.r#scope = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11070 -                         self.r#scope = value.into();
[INFO] [stdout] 11070 +                         self.r#scope = <InstrumentationScope as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11127:45
[INFO] [stdout]       |
[INFO] [stdout] 11127 |                         self.r#schema_url = value.into();
[INFO] [stdout]       |                                             ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11127 -                         self.r#schema_url = value.into();
[INFO] [stdout] 11127 +                         self.r#schema_url = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11127 -                         self.r#schema_url = value.into();
[INFO] [stdout] 11127 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11136:45
[INFO] [stdout]       |
[INFO] [stdout] 11136 |                         self.r#schema_url = value.into();
[INFO] [stdout]       |                                             ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11136 -                         self.r#schema_url = value.into();
[INFO] [stdout] 11136 +                         self.r#schema_url = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11136 -                         self.r#schema_url = value.into();
[INFO] [stdout] 11136 +                         self.r#schema_url = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11491:43
[INFO] [stdout]       |
[INFO] [stdout] 11491 |                         self.r#trace_id = value.into();
[INFO] [stdout]       |                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11491 -                         self.r#trace_id = value.into();
[INFO] [stdout] 11491 +                         self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11491 -                         self.r#trace_id = value.into();
[INFO] [stdout] 11491 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11497:43
[INFO] [stdout]       |
[INFO] [stdout] 11497 |                         self.r#trace_id = value.into();
[INFO] [stdout]       |                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11497 -                         self.r#trace_id = value.into();
[INFO] [stdout] 11497 +                         self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11497 -                         self.r#trace_id = value.into();
[INFO] [stdout] 11497 +                         self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11516:42
[INFO] [stdout]       |
[INFO] [stdout] 11516 |                         self.r#span_id = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11516 -                         self.r#span_id = value.into();
[INFO] [stdout] 11516 +                         self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11516 -                         self.r#span_id = value.into();
[INFO] [stdout] 11516 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11522:42
[INFO] [stdout]       |
[INFO] [stdout] 11522 |                         self.r#span_id = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11522 -                         self.r#span_id = value.into();
[INFO] [stdout] 11522 +                         self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11522 -                         self.r#span_id = value.into();
[INFO] [stdout] 11522 +                         self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11541:46
[INFO] [stdout]       |
[INFO] [stdout] 11541 |                         self.r#trace_state = value.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11541 -                         self.r#trace_state = value.into();
[INFO] [stdout] 11541 +                         self.r#trace_state = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11541 -                         self.r#trace_state = value.into();
[INFO] [stdout] 11541 +                         self.r#trace_state = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11550:46
[INFO] [stdout]       |
[INFO] [stdout] 11550 |                         self.r#trace_state = value.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11550 -                         self.r#trace_state = value.into();
[INFO] [stdout] 11550 +                         self.r#trace_state = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11550 -                         self.r#trace_state = value.into();
[INFO] [stdout] 11550 +                         self.r#trace_state = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11569:49
[INFO] [stdout]       |
[INFO] [stdout] 11569 |                         self.r#parent_span_id = value.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11569 -                         self.r#parent_span_id = value.into();
[INFO] [stdout] 11569 +                         self.r#parent_span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11569 -                         self.r#parent_span_id = value.into();
[INFO] [stdout] 11569 +                         self.r#parent_span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:11578:49
[INFO] [stdout]       |
[INFO] [stdout] 11578 |                         self.r#parent_span_id = value.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11578 -                         self.r#parent_span_id = value.into();
[INFO] [stdout] 11578 +                         self.r#parent_span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11578 -                         self.r#parent_span_id = value.into();
[INFO] [stdout] 11578 +                         self.r#parent_span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11594:40
[INFO] [stdout]       |
[INFO] [stdout] 11594 |                         self.r#flags = value.into();
[INFO] [stdout]       |                                        ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11594 -                         self.r#flags = value.into();
[INFO] [stdout] 11594 +                         self.r#flags = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11594 -                         self.r#flags = value.into();
[INFO] [stdout] 11594 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11600:40
[INFO] [stdout]       |
[INFO] [stdout] 11600 |                         self.r#flags = value.into();
[INFO] [stdout]       |                                        ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11600 -                         self.r#flags = value.into();
[INFO] [stdout] 11600 +                         self.r#flags = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11600 -                         self.r#flags = value.into();
[INFO] [stdout] 11600 +                         self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11619:39
[INFO] [stdout]       |
[INFO] [stdout] 11619 |                         self.r#name = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11619 -                         self.r#name = value.into();
[INFO] [stdout] 11619 +                         self.r#name = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11619 -                         self.r#name = value.into();
[INFO] [stdout] 11619 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:11625:39
[INFO] [stdout]       |
[INFO] [stdout] 11625 |                         self.r#name = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11625 -                         self.r#name = value.into();
[INFO] [stdout] 11625 +                         self.r#name = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11625 -                         self.r#name = value.into();
[INFO] [stdout] 11625 +                         self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpanKind`
[INFO] [stdout]      --> src/generated_std.rs:11641:39
[INFO] [stdout]       |
[INFO] [stdout] 11641 |                         self.r#kind = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11641 -                         self.r#kind = value.into();
[INFO] [stdout] 11641 +                         self.r#kind = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11641 -                         self.r#kind = value.into();
[INFO] [stdout] 11641 +                         self.r#kind = <SpanKind as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `SpanKind`
[INFO] [stdout]      --> src/generated_std.rs:11647:39
[INFO] [stdout]       |
[INFO] [stdout] 11647 |                         self.r#kind = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11647 -                         self.r#kind = value.into();
[INFO] [stdout] 11647 +                         self.r#kind = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11647 -                         self.r#kind = value.into();
[INFO] [stdout] 11647 +                         self.r#kind = <SpanKind as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:11663:55
[INFO] [stdout]       |
[INFO] [stdout] 11663 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11663 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 11663 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11663 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 11663 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:11669:55
[INFO] [stdout]       |
[INFO] [stdout] 11669 |                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11669 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 11669 +                         self.r#start_time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11669 -                         self.r#start_time_unix_nano = value.into();
[INFO] [stdout] 11669 +                         self.r#start_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:11685:53
[INFO] [stdout]       |
[INFO] [stdout] 11685 |                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11685 -                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout] 11685 +                         self.r#end_time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11685 -                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout] 11685 +                         self.r#end_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:11691:53
[INFO] [stdout]       |
[INFO] [stdout] 11691 |                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11691 -                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout] 11691 +                         self.r#end_time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11691 -                         self.r#end_time_unix_nano = value.into();
[INFO] [stdout] 11691 +                         self.r#end_time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11710:59
[INFO] [stdout]       |
[INFO] [stdout] 11710 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11710 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 11710 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11710 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 11710 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11716:59
[INFO] [stdout]       |
[INFO] [stdout] 11716 |                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                           ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11716 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 11716 +                         self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11716 -                         self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 11716 +                         self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11732:55
[INFO] [stdout]       |
[INFO] [stdout] 11732 |                         self.r#dropped_events_count = value.into();
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11732 -                         self.r#dropped_events_count = value.into();
[INFO] [stdout] 11732 +                         self.r#dropped_events_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11732 -                         self.r#dropped_events_count = value.into();
[INFO] [stdout] 11732 +                         self.r#dropped_events_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11738:55
[INFO] [stdout]       |
[INFO] [stdout] 11738 |                         self.r#dropped_events_count = value.into();
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11738 -                         self.r#dropped_events_count = value.into();
[INFO] [stdout] 11738 +                         self.r#dropped_events_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11738 -                         self.r#dropped_events_count = value.into();
[INFO] [stdout] 11738 +                         self.r#dropped_events_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11754:54
[INFO] [stdout]       |
[INFO] [stdout] 11754 |                         self.r#dropped_links_count = value.into();
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11754 -                         self.r#dropped_links_count = value.into();
[INFO] [stdout] 11754 +                         self.r#dropped_links_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11754 -                         self.r#dropped_links_count = value.into();
[INFO] [stdout] 11754 +                         self.r#dropped_links_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:11760:54
[INFO] [stdout]       |
[INFO] [stdout] 11760 |                         self.r#dropped_links_count = value.into();
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11760 -                         self.r#dropped_links_count = value.into();
[INFO] [stdout] 11760 +                         self.r#dropped_links_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11760 -                         self.r#dropped_links_count = value.into();
[INFO] [stdout] 11760 +                         self.r#dropped_links_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Status`
[INFO] [stdout]      --> src/generated_std.rs:11772:41
[INFO] [stdout]       |
[INFO] [stdout] 11772 |                         self.r#status = value.into();
[INFO] [stdout]       |                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11772 -                         self.r#status = value.into();
[INFO] [stdout] 11772 +                         self.r#status = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11772 -                         self.r#status = value.into();
[INFO] [stdout] 11772 +                         self.r#status = <Status as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:12447:53
[INFO] [stdout]       |
[INFO] [stdout] 12447 | ...                   self.r#time_unix_nano = value.into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12447 -                             self.r#time_unix_nano = value.into();
[INFO] [stdout] 12447 +                             self.r#time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12447 -                             self.r#time_unix_nano = value.into();
[INFO] [stdout] 12447 +                             self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/generated_std.rs:12453:53
[INFO] [stdout]       |
[INFO] [stdout] 12453 | ...                   self.r#time_unix_nano = value.into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12453 -                             self.r#time_unix_nano = value.into();
[INFO] [stdout] 12453 +                             self.r#time_unix_nano = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12453 -                             self.r#time_unix_nano = value.into();
[INFO] [stdout] 12453 +                             self.r#time_unix_nano = <u64 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:12472:43
[INFO] [stdout]       |
[INFO] [stdout] 12472 | ...                   self.r#name = value.into();
[INFO] [stdout]       |                                     ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12472 -                             self.r#name = value.into();
[INFO] [stdout] 12472 +                             self.r#name = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12472 -                             self.r#name = value.into();
[INFO] [stdout] 12472 +                             self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:12481:43
[INFO] [stdout]       |
[INFO] [stdout] 12481 | ...                   self.r#name = value.into();
[INFO] [stdout]       |                                     ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12481 -                             self.r#name = value.into();
[INFO] [stdout] 12481 +                             self.r#name = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12481 -                             self.r#name = value.into();
[INFO] [stdout] 12481 +                             self.r#name = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12500:63
[INFO] [stdout]       |
[INFO] [stdout] 12500 | ...                   self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12500 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12500 +                             self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12500 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12500 +                             self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12509:63
[INFO] [stdout]       |
[INFO] [stdout] 12509 | ...                   self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12509 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12509 +                             self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12509 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12509 +                             self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:12757:47
[INFO] [stdout]       |
[INFO] [stdout] 12757 | ...                   self.r#trace_id = value.into();
[INFO] [stdout]       |                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12757 -                             self.r#trace_id = value.into();
[INFO] [stdout] 12757 +                             self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12757 -                             self.r#trace_id = value.into();
[INFO] [stdout] 12757 +                             self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:12766:47
[INFO] [stdout]       |
[INFO] [stdout] 12766 | ...                   self.r#trace_id = value.into();
[INFO] [stdout]       |                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12766 -                             self.r#trace_id = value.into();
[INFO] [stdout] 12766 +                             self.r#trace_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12766 -                             self.r#trace_id = value.into();
[INFO] [stdout] 12766 +                             self.r#trace_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:12785:46
[INFO] [stdout]       |
[INFO] [stdout] 12785 | ...                   self.r#span_id = value.into();
[INFO] [stdout]       |                                        ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12785 -                             self.r#span_id = value.into();
[INFO] [stdout] 12785 +                             self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12785 -                             self.r#span_id = value.into();
[INFO] [stdout] 12785 +                             self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]      --> src/generated_std.rs:12794:46
[INFO] [stdout]       |
[INFO] [stdout] 12794 | ...                   self.r#span_id = value.into();
[INFO] [stdout]       |                                        ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12794 -                             self.r#span_id = value.into();
[INFO] [stdout] 12794 +                             self.r#span_id = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12794 -                             self.r#span_id = value.into();
[INFO] [stdout] 12794 +                             self.r#span_id = <Vec<u8> as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:12813:50
[INFO] [stdout]       |
[INFO] [stdout] 12813 | ...                   self.r#trace_state = value.into();
[INFO] [stdout]       |                                            ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12813 -                             self.r#trace_state = value.into();
[INFO] [stdout] 12813 +                             self.r#trace_state = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12813 -                             self.r#trace_state = value.into();
[INFO] [stdout] 12813 +                             self.r#trace_state = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:12822:50
[INFO] [stdout]       |
[INFO] [stdout] 12822 | ...                   self.r#trace_state = value.into();
[INFO] [stdout]       |                                            ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12822 -                             self.r#trace_state = value.into();
[INFO] [stdout] 12822 +                             self.r#trace_state = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12822 -                             self.r#trace_state = value.into();
[INFO] [stdout] 12822 +                             self.r#trace_state = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12841:63
[INFO] [stdout]       |
[INFO] [stdout] 12841 | ...                   self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12841 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12841 +                             self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12841 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12841 +                             self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12850:63
[INFO] [stdout]       |
[INFO] [stdout] 12850 | ...                   self.r#dropped_attributes_count = value.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12850 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12850 +                             self.r#dropped_attributes_count = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12850 -                             self.r#dropped_attributes_count = value.into();
[INFO] [stdout] 12850 +                             self.r#dropped_attributes_count = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12866:44
[INFO] [stdout]       |
[INFO] [stdout] 12866 | ...                   self.r#flags = value.into();
[INFO] [stdout]       |                                      ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12866 -                             self.r#flags = value.into();
[INFO] [stdout] 12866 +                             self.r#flags = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12866 -                             self.r#flags = value.into();
[INFO] [stdout] 12866 +                             self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/generated_std.rs:12872:44
[INFO] [stdout]       |
[INFO] [stdout] 12872 | ...                   self.r#flags = value.into();
[INFO] [stdout]       |                                      ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12872 -                             self.r#flags = value.into();
[INFO] [stdout] 12872 +                             self.r#flags = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12872 -                             self.r#flags = value.into();
[INFO] [stdout] 12872 +                             self.r#flags = <u32 as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:13230:42
[INFO] [stdout]       |
[INFO] [stdout] 13230 |                         self.r#message = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13230 -                         self.r#message = value.into();
[INFO] [stdout] 13230 +                         self.r#message = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13230 -                         self.r#message = value.into();
[INFO] [stdout] 13230 +                         self.r#message = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]      --> src/generated_std.rs:13236:42
[INFO] [stdout]       |
[INFO] [stdout] 13236 |                         self.r#message = value.into();
[INFO] [stdout]       |                                          ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13236 -                         self.r#message = value.into();
[INFO] [stdout] 13236 +                         self.r#message = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13236 -                         self.r#message = value.into();
[INFO] [stdout] 13236 +                         self.r#message = <String as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `StatusCode`
[INFO] [stdout]      --> src/generated_std.rs:13252:39
[INFO] [stdout]       |
[INFO] [stdout] 13252 |                         self.r#code = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13252 -                         self.r#code = value.into();
[INFO] [stdout] 13252 +                         self.r#code = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13252 -                         self.r#code = value.into();
[INFO] [stdout] 13252 +                         self.r#code = <StatusCode as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `StatusCode`
[INFO] [stdout]      --> src/generated_std.rs:13258:39
[INFO] [stdout]       |
[INFO] [stdout] 13258 |                         self.r#code = value.into();
[INFO] [stdout]       |                                       ^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13258 -                         self.r#code = value.into();
[INFO] [stdout] 13258 +                         self.r#code = value;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13258 -                         self.r#code = value.into();
[INFO] [stdout] 13258 +                         self.r#code = <StatusCode as Into<_>>::into(value);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `opentelemetry-micropb` (lib) due to 186 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b", kill_on_drop: false }`
[INFO] [stdout] 3fe617e96cb6e6baa3a892b38fd4c5e3aabc734a3b4d36671010b8c27ea3f15b
