[INFO] fetching crate zerodds-spatial-dds 1.0.0-rc.6...
[INFO] checking zerodds-spatial-dds-1.0.0-rc.6 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate zerodds-spatial-dds 1.0.0-rc.6 into /workspace/builds/worker-6-tc2/source
[INFO] started tweaking crates.io crate zerodds-spatial-dds 1.0.0-rc.6
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate zerodds-spatial-dds 1.0.0-rc.6
[INFO] tweaked toml for crates.io crate zerodds-spatial-dds 1.0.0-rc.6 written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate zerodds-spatial-dds 1.0.0-rc.6 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 zerodds-spatial-dds 1.0.0-rc.6 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b
[INFO] running `Command { std: "docker" "start" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b", 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" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b", 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" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling zerodds-foundation v1.0.0-rc.6
[INFO] [stderr]     Checking zerodds-cdr v1.0.0-rc.6
[INFO] [stderr]     Checking zerodds-types v1.0.0-rc.6
[INFO] [stderr]    Compiling num-integer v0.1.46
[INFO] [stderr]    Compiling num-bigint v0.4.6
[INFO] [stderr]    Compiling zerodds-idl v1.0.0-rc.6
[INFO] [stderr]    Compiling zerodds-idl-rust v1.0.0-rc.6
[INFO] [stderr]    Compiling zerodds-spatial-dds v1.0.0-rc.6 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]    --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:285:62
[INFO] [stdout]     |
[INFO] [stdout] 285 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 285 -                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout] 285 +                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout] 285 +                         if self.meta.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]    --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:292:58
[INFO] [stdout]     |
[INFO] [stdout] 292 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout] 292 +                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout] 292 +                     if self.meta.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1032:76
[INFO] [stdout]      |
[INFO] [stdout] 1032 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1032 -                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout] 1032 +                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1032 -                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout] 1032 +                         if self.supported_profiles.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1033:76
[INFO] [stdout]      |
[INFO] [stdout] 1033 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1033 -                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout] 1033 +                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1033 -                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout] 1033 +                         if self.preferred_profiles.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1034:66
[INFO] [stdout]      |
[INFO] [stdout] 1034 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout] 1034 +                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout] 1034 +                         if self.features.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1038:72
[INFO] [stdout]      |
[INFO] [stdout] 1038 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout] 1038 +                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout] 1038 +                     if self.supported_profiles.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1039:72
[INFO] [stdout]      |
[INFO] [stdout] 1039 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1039 -                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout] 1039 +                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 -                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout] 1039 +                     if self.preferred_profiles.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1040:62
[INFO] [stdout]      |
[INFO] [stdout] 1040 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1040 -                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout] 1040 +                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1040 -                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout] 1040 +                     if self.features.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1518:63
[INFO] [stdout]      |
[INFO] [stdout] 1518 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1518 -                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout] 1518 +                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1518 -                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout] 1518 +                         if self.hints.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1520:65
[INFO] [stdout]      |
[INFO] [stdout] 1520 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1520 -                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout] 1520 +                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1520 -                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout] 1520 +                         if self.topics.len() > 128 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1521:66
[INFO] [stdout]      |
[INFO] [stdout] 1521 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout] 1521 +                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1521 -                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout] 1521 +                         if self.coverage.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1525:67
[INFO] [stdout]      |
[INFO] [stdout] 1525 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1525 -                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout] 1525 +                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1525 -                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout] 1525 +                         if self.transforms.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1538:59
[INFO] [stdout]      |
[INFO] [stdout] 1538 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1538 -                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout] 1538 +                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1538 -                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout] 1538 +                     if self.hints.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1540:61
[INFO] [stdout]      |
[INFO] [stdout] 1540 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1540 -                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout] 1540 +                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1540 -                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout] 1540 +                     if self.topics.len() > 128 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1541:62
[INFO] [stdout]      |
[INFO] [stdout] 1541 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1541 -                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout] 1541 +                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1541 -                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout] 1541 +                     if self.coverage.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1545:63
[INFO] [stdout]      |
[INFO] [stdout] 1545 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1545 -                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout] 1545 +                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1545 -                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout] 1545 +                     if self.transforms.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1712:61
[INFO] [stdout]      |
[INFO] [stdout] 1712 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1712 -                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1712 +                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1712 -                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1712 +                         if self.tags.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1722:57
[INFO] [stdout]      |
[INFO] [stdout] 1722 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1722 -                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1722 +                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1722 -                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1722 +                     if self.tags.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1799:62
[INFO] [stdout]      |
[INFO] [stdout] 1799 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1799 -                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1799 +                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1799 -                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1799 +                         if self.tags.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1803:66
[INFO] [stdout]      |
[INFO] [stdout] 1803 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1803 -                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout] 1803 +                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1803 -                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout] 1803 +                         if self.anchors.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1814:58
[INFO] [stdout]      |
[INFO] [stdout] 1814 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1814 -                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1814 +                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1814 -                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1814 +                     if self.tags.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1818:62
[INFO] [stdout]      |
[INFO] [stdout] 1818 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1818 -                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout] 1818 +                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1818 -                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout] 1818 +                     if self.anchors.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2128:71
[INFO] [stdout]      |
[INFO] [stdout] 2128 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2128 -                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2128 +                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }); } 
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2128 -                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2128 +                                     if __v.len() > 65535 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" })); } 
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2142:67
[INFO] [stdout]      |
[INFO] [stdout] 2142 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2142 -                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2142 +                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }); } 
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2142 -                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2142 +                                 if __v.len() > 65535 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" })); } 
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2626:68
[INFO] [stdout]      |
[INFO] [stdout] 2626 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2626 -                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout] 2626 +                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2626 -                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout] 2626 +                             if self.blobs.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2636:64
[INFO] [stdout]      |
[INFO] [stdout] 2636 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2636 -                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout] 2636 +                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2636 -                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout] 2636 +                         if self.blobs.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2923:68
[INFO] [stdout]      |
[INFO] [stdout] 2923 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2923 -                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout] 2923 +                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2923 -                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout] 2923 +                             if self.frames.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2929:64
[INFO] [stdout]      |
[INFO] [stdout] 2929 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2929 -                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout] 2929 +                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2929 -                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout] 2929 +                         if self.frames.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3180:73
[INFO] [stdout]      |
[INFO] [stdout] 3180 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3180 -                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout] 3180 +                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3180 -                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout] 3180 +                             if self.dist_params.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3197:69
[INFO] [stdout]      |
[INFO] [stdout] 3197 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3197 -                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout] 3197 +                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3197 -                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout] 3197 +                         if self.dist_params.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3344:69
[INFO] [stdout]      |
[INFO] [stdout] 3344 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3344 -                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout] 3344 +                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3344 -                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout] 3344 +                             if self.trail.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3349:65
[INFO] [stdout]      |
[INFO] [stdout] 3349 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3349 -                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout] 3349 +                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3349 -                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout] 3349 +                         if self.trail.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3395:73
[INFO] [stdout]      |
[INFO] [stdout] 3395 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3395 -                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 3395 +                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3395 -                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 3395 +                             if self.keypoints.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3396:70
[INFO] [stdout]      |
[INFO] [stdout] 3396 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3396 -                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout] 3396 +                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3396 -                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout] 3396 +                             if self.tracks.len() > 2048 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3403:69
[INFO] [stdout]      |
[INFO] [stdout] 3403 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3403 -                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 3403 +                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3403 -                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 3403 +                         if self.keypoints.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3404:66
[INFO] [stdout]      |
[INFO] [stdout] 3404 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3404 -                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout] 3404 +                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3404 -                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout] 3404 +                         if self.tracks.len() > 2048 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3966:67
[INFO] [stdout]      |
[INFO] [stdout] 3966 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3966 -                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 3966 +                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3966 -                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 3966 +                             if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3974:63
[INFO] [stdout]      |
[INFO] [stdout] 3974 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3974 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 3974 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3974 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 3974 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4532:69
[INFO] [stdout]      |
[INFO] [stdout] 4532 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } ...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4532 -                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 4532 +                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4532 -                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 4532 +                             if self.dets.len() > 32768 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4545:65
[INFO] [stdout]      |
[INFO] [stdout] 4545 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } ...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4545 -                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 4545 +                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4545 -                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 4545 +                         if self.dets.len() > 32768 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4693:65
[INFO] [stdout]      |
[INFO] [stdout] 4693 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4693 -                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout] 4693 +                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4693 -                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout] 4693 +                             if self.axes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4719:61
[INFO] [stdout]      |
[INFO] [stdout] 4719 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4719 -                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout] 4719 +                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4719 -                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout] 4719 +                         if self.axes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5082:63
[INFO] [stdout]      |
[INFO] [stdout] 5082 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5082 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5082 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5082 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5082 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5091:59
[INFO] [stdout]      |
[INFO] [stdout] 5091 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5091 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5091 +                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5091 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5091 +                     if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5187:67
[INFO] [stdout]      |
[INFO] [stdout] 5187 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5187 -                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout] 5187 +                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5187 -                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout] 5187 +                         if self.attributes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5213:63
[INFO] [stdout]      |
[INFO] [stdout] 5213 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5213 -                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout] 5213 +                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5213 -                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout] 5213 +                     if self.attributes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5351:63
[INFO] [stdout]      |
[INFO] [stdout] 5351 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5351 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5351 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5351 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5351 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5361:59
[INFO] [stdout]      |
[INFO] [stdout] 5361 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5361 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5361 +                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5361 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5361 +                     if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5490:61
[INFO] [stdout]      |
[INFO] [stdout] 5490 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5490 -                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout] 5490 +                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5490 -                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout] 5490 +                         if self.dist.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5504:57
[INFO] [stdout]      |
[INFO] [stdout] 5504 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5504 -                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout] 5504 +                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5504 -                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout] 5504 +                     if self.dist.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5662:69
[INFO] [stdout]      |
[INFO] [stdout] 5662 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5662 -                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 5662 +                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5662 -                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 5662 +                         if self.keypoints.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5663:74
[INFO] [stdout]      |
[INFO] [stdout] 5663 | ...Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); }...
[INFO] [stdout]      |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5663 -                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout] 5663 +                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5663 -                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout] 5663 +                         if self.descriptors.len() > 1048576 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5675:65
[INFO] [stdout]      |
[INFO] [stdout] 5675 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5675 -                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 5675 +                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5675 -                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 5675 +                     if self.keypoints.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5676:70
[INFO] [stdout]      |
[INFO] [stdout] 5676 | ...Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); }...
[INFO] [stdout]      |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5676 -                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout] 5676 +                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5676 -                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout] 5676 +                     if self.descriptors.len() > 1048576 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5821:67
[INFO] [stdout]      |
[INFO] [stdout] 5821 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5821 -                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout] 5821 +                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5821 -                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout] 5821 +                         if self.matches.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5828:63
[INFO] [stdout]      |
[INFO] [stdout] 5828 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5828 -                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout] 5828 +                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5828 -                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout] 5828 +                     if self.matches.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5891:64
[INFO] [stdout]      |
[INFO] [stdout] 5891 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5891 -                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout] 5891 +                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5891 -                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout] 5891 +                         if self.desc.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5904:60
[INFO] [stdout]      |
[INFO] [stdout] 5904 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5904 -                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout] 5904 +                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5904 -                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout] 5904 +                     if self.desc.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6040:61
[INFO] [stdout]      |
[INFO] [stdout] 6040 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6040 -                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout] 6040 +                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6040 -                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout] 6040 +                         if self.obs.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6049:57
[INFO] [stdout]      |
[INFO] [stdout] 6049 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6049 -                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout] 6049 +                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6049 -                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout] 6049 +                     if self.obs.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6730:62
[INFO] [stdout]      |
[INFO] [stdout] 6730 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6730 -                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout] 6730 +                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6730 -                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout] 6730 +                         if self.poses.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6741:58
[INFO] [stdout]      |
[INFO] [stdout] 6741 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6741 -                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout] 6741 +                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6741 -                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout] 6741 +                     if self.poses.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]    --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:285:62
[INFO] [stdout]     |
[INFO] [stdout] 285 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 285 -                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout] 285 +                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -                         if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout] 285 +                         if self.meta.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, w)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]    --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:292:58
[INFO] [stdout]     |
[INFO] [stdout] 292 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout] 292 +                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     if self.meta.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout] 292 +                     if self.meta.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.meta, writer)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1032:76
[INFO] [stdout]      |
[INFO] [stdout] 1032 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1032 -                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout] 1032 +                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1032 -                         if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout] 1032 +                         if self.supported_profiles.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1033:76
[INFO] [stdout]      |
[INFO] [stdout] 1033 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1033 -                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout] 1033 +                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1033 -                         if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout] 1033 +                         if self.preferred_profiles.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1034:66
[INFO] [stdout]      |
[INFO] [stdout] 1034 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout] 1034 +                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout] 1034 +                         if self.features.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1038:72
[INFO] [stdout]      |
[INFO] [stdout] 1038 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout] 1038 +                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     if self.supported_profiles.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout] 1038 +                     if self.supported_profiles.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.supported_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1039:72
[INFO] [stdout]      |
[INFO] [stdout] 1039 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1039 -                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout] 1039 +                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 -                     if self.preferred_profiles.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout] 1039 +                     if self.preferred_profiles.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.preferred_profiles, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1040:62
[INFO] [stdout]      |
[INFO] [stdout] 1040 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1040 -                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout] 1040 +                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1040 -                     if self.features.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout] 1040 +                     if self.features.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.features, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1518:63
[INFO] [stdout]      |
[INFO] [stdout] 1518 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1518 -                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout] 1518 +                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1518 -                         if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout] 1518 +                         if self.hints.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1520:65
[INFO] [stdout]      |
[INFO] [stdout] 1520 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1520 -                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout] 1520 +                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1520 -                         if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout] 1520 +                         if self.topics.len() > 128 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1521:66
[INFO] [stdout]      |
[INFO] [stdout] 1521 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout] 1521 +                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1521 -                         if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout] 1521 +                         if self.coverage.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1525:67
[INFO] [stdout]      |
[INFO] [stdout] 1525 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1525 -                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout] 1525 +                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1525 -                         if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout] 1525 +                         if self.transforms.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1538:59
[INFO] [stdout]      |
[INFO] [stdout] 1538 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1538 -                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout] 1538 +                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1538 -                     if self.hints.len() > 32 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout] 1538 +                     if self.hints.len() > 32 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.hints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1540:61
[INFO] [stdout]      |
[INFO] [stdout] 1540 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1540 -                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout] 1540 +                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1540 -                     if self.topics.len() > 128 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout] 1540 +                     if self.topics.len() > 128 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (128)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.topics, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1541:62
[INFO] [stdout]      |
[INFO] [stdout] 1541 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1541 -                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout] 1541 +                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1541 -                     if self.coverage.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout] 1541 +                     if self.coverage.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.coverage, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1545:63
[INFO] [stdout]      |
[INFO] [stdout] 1545 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1545 -                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout] 1545 +                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1545 -                     if self.transforms.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout] 1545 +                     if self.transforms.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.transforms, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1712:61
[INFO] [stdout]      |
[INFO] [stdout] 1712 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1712 -                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1712 +                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1712 -                         if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1712 +                         if self.tags.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1722:57
[INFO] [stdout]      |
[INFO] [stdout] 1722 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1722 -                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1722 +                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1722 -                     if self.tags.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1722 +                     if self.tags.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1799:62
[INFO] [stdout]      |
[INFO] [stdout] 1799 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1799 -                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1799 +                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1799 -                         if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout] 1799 +                         if self.tags.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1803:66
[INFO] [stdout]      |
[INFO] [stdout] 1803 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1803 -                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout] 1803 +                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1803 -                         if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout] 1803 +                         if self.anchors.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1814:58
[INFO] [stdout]      |
[INFO] [stdout] 1814 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1814 -                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1814 +                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1814 -                     if self.tags.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout] 1814 +                     if self.tags.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tags, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:1818:62
[INFO] [stdout]      |
[INFO] [stdout] 1818 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1818 -                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout] 1818 +                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1818 -                     if self.anchors.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout] 1818 +                     if self.anchors.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.anchors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2128:71
[INFO] [stdout]      |
[INFO] [stdout] 2128 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2128 -                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2128 +                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }); } 
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2128 -                                     if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2128 +                                     if __v.len() > 65535 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" })); } 
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2142:67
[INFO] [stdout]      |
[INFO] [stdout] 2142 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2142 -                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2142 +                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }); } 
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2142 -                                 if __v.len() > 65535 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" }.into()); } 
[INFO] [stdout] 2142 +                                 if __v.len() > 65535 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (65535)" })); } 
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2626:68
[INFO] [stdout]      |
[INFO] [stdout] 2626 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2626 -                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout] 2626 +                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2626 -                             if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout] 2626 +                             if self.blobs.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2636:64
[INFO] [stdout]      |
[INFO] [stdout] 2636 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2636 -                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout] 2636 +                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2636 -                         if self.blobs.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout] 2636 +                         if self.blobs.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.blobs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2923:68
[INFO] [stdout]      |
[INFO] [stdout] 2923 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2923 -                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout] 2923 +                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2923 -                             if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout] 2923 +                             if self.frames.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:2929:64
[INFO] [stdout]      |
[INFO] [stdout] 2929 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2929 -                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout] 2929 +                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2929 -                         if self.frames.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout] 2929 +                         if self.frames.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.frames, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3180:73
[INFO] [stdout]      |
[INFO] [stdout] 3180 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3180 -                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout] 3180 +                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3180 -                             if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout] 3180 +                             if self.dist_params.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3197:69
[INFO] [stdout]      |
[INFO] [stdout] 3197 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3197 -                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout] 3197 +                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3197 -                         if self.dist_params.len() > 16 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout] 3197 +                         if self.dist_params.len() > 16 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (16)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist_params, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3344:69
[INFO] [stdout]      |
[INFO] [stdout] 3344 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3344 -                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout] 3344 +                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3344 -                             if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout] 3344 +                             if self.trail.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3349:65
[INFO] [stdout]      |
[INFO] [stdout] 3349 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3349 -                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout] 3349 +                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3349 -                         if self.trail.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout] 3349 +                         if self.trail.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.trail, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3395:73
[INFO] [stdout]      |
[INFO] [stdout] 3395 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3395 -                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 3395 +                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3395 -                             if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 3395 +                             if self.keypoints.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3396:70
[INFO] [stdout]      |
[INFO] [stdout] 3396 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3396 -                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout] 3396 +                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3396 -                             if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout] 3396 +                             if self.tracks.len() > 2048 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3403:69
[INFO] [stdout]      |
[INFO] [stdout] 3403 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3403 -                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 3403 +                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3403 -                         if self.keypoints.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 3403 +                         if self.keypoints.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3404:66
[INFO] [stdout]      |
[INFO] [stdout] 3404 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3404 -                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout] 3404 +                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3404 -                         if self.tracks.len() > 2048 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout] 3404 +                         if self.tracks.len() > 2048 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (2048)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.tracks, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3966:67
[INFO] [stdout]      |
[INFO] [stdout] 3966 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3966 -                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 3966 +                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3966 -                             if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 3966 +                             if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:3974:63
[INFO] [stdout]      |
[INFO] [stdout] 3974 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3974 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 3974 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3974 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 3974 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4532:69
[INFO] [stdout]      |
[INFO] [stdout] 4532 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } ...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4532 -                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 4532 +                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4532 -                             if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 4532 +                             if self.dets.len() > 32768 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4545:65
[INFO] [stdout]      |
[INFO] [stdout] 4545 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } ...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4545 -                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 4545 +                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4545 -                         if self.dets.len() > 32768 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 4545 +                         if self.dets.len() > 32768 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (32768)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4693:65
[INFO] [stdout]      |
[INFO] [stdout] 4693 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4693 -                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout] 4693 +                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4693 -                             if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout] 4693 +                             if self.axes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:4719:61
[INFO] [stdout]      |
[INFO] [stdout] 4719 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4719 -                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout] 4719 +                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4719 -                         if self.axes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout] 4719 +                         if self.axes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.axes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5082:63
[INFO] [stdout]      |
[INFO] [stdout] 5082 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5082 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5082 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5082 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5082 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5091:59
[INFO] [stdout]      |
[INFO] [stdout] 5091 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5091 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5091 +                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5091 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5091 +                     if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5187:67
[INFO] [stdout]      |
[INFO] [stdout] 5187 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5187 -                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout] 5187 +                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5187 -                         if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout] 5187 +                         if self.attributes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5213:63
[INFO] [stdout]      |
[INFO] [stdout] 5213 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5213 -                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout] 5213 +                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5213 -                     if self.attributes.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout] 5213 +                     if self.attributes.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.attributes, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5351:63
[INFO] [stdout]      |
[INFO] [stdout] 5351 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5351 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5351 +                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5351 -                         if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout] 5351 +                         if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5361:59
[INFO] [stdout]      |
[INFO] [stdout] 5361 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5361 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5361 +                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5361 -                     if self.dets.len() > 256 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout] 5361 +                     if self.dets.len() > 256 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (256)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dets, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5490:61
[INFO] [stdout]      |
[INFO] [stdout] 5490 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5490 -                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout] 5490 +                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5490 -                         if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout] 5490 +                         if self.dist.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5504:57
[INFO] [stdout]      |
[INFO] [stdout] 5504 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5504 -                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout] 5504 +                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5504 -                     if self.dist.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout] 5504 +                     if self.dist.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.dist, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5662:69
[INFO] [stdout]      |
[INFO] [stdout] 5662 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5662 -                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 5662 +                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5662 -                         if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout] 5662 +                         if self.keypoints.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5663:74
[INFO] [stdout]      |
[INFO] [stdout] 5663 | ...Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); }...
[INFO] [stdout]      |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5663 -                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout] 5663 +                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5663 -                         if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout] 5663 +                         if self.descriptors.len() > 1048576 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5675:65
[INFO] [stdout]      |
[INFO] [stdout] 5675 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5675 -                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 5675 +                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5675 -                     if self.keypoints.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout] 5675 +                     if self.keypoints.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.keypoints, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5676:70
[INFO] [stdout]      |
[INFO] [stdout] 5676 | ...Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); }...
[INFO] [stdout]      |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5676 -                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout] 5676 +                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5676 -                     if self.descriptors.len() > 1048576 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout] 5676 +                     if self.descriptors.len() > 1048576 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (1048576)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.descriptors, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5821:67
[INFO] [stdout]      |
[INFO] [stdout] 5821 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5821 -                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout] 5821 +                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5821 -                         if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout] 5821 +                         if self.matches.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5828:63
[INFO] [stdout]      |
[INFO] [stdout] 5828 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5828 -                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout] 5828 +                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5828 -                     if self.matches.len() > 8192 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout] 5828 +                     if self.matches.len() > 8192 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8192)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.matches, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5891:64
[INFO] [stdout]      |
[INFO] [stdout] 5891 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5891 -                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout] 5891 +                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5891 -                         if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout] 5891 +                         if self.desc.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:5904:60
[INFO] [stdout]      |
[INFO] [stdout] 5904 | ... Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <...
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5904 -                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout] 5904 +                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5904 -                     if self.desc.len() > 4096 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout] 5904 +                     if self.desc.len() > 4096 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (4096)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.desc, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6040:61
[INFO] [stdout]      |
[INFO] [stdout] 6040 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6040 -                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout] 6040 +                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6040 -                         if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout] 6040 +                         if self.obs.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6049:57
[INFO] [stdout]      |
[INFO] [stdout] 6049 | ...n Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_...
[INFO] [stdout]      |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6049 -                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout] 6049 +                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6049 -                     if self.obs.len() > 64 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout] 6049 +                     if self.obs.len() > 64 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (64)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.obs, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6730:62
[INFO] [stdout]      |
[INFO] [stdout] 6730 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6730 -                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout] 6730 +                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6730 -                         if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout] 6730 +                         if self.poses.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, w)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `EncodeError`
[INFO] [stdout]     --> /opt/rustwide/target/debug/build/zerodds-spatial-dds/efdeaec8843ced3f/out/spatial_core.rs:6741:58
[INFO] [stdout]      |
[INFO] [stdout] 6741 | ...rn Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_...
[INFO] [stdout]      |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6741 -                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout] 6741 +                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6741 -                     if self.poses.len() > 8 { return Err(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" }.into()); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout] 6741 +                     if self.poses.len() > 8 { return Err(<EncodeError as Into<_>>::into(zerodds_cdr::EncodeError::ValueOutOfRange { message: "bounded sequence length exceeds its IDL bound (8)" })); } <_ as zerodds_cdr::CdrEncode>::encode(&self.poses, writer)?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zerodds-spatial-dds` (lib test) due to 62 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `zerodds-spatial-dds` (lib) due to 62 previous errors
[INFO] [stderr] warning: unused dependency `zerodds-types`
[INFO] [stderr]   --> Cargo.toml:12:15
[INFO] [stderr]    |
[INFO] [stderr] 12 | [dependencies.zerodds-types]
[INFO] [stderr]    |               ^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `zerodds-types`
[INFO] [stderr] warning: `zerodds-spatial-dds` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b", kill_on_drop: false }`
[INFO] [stdout] 476ed33b053543177269f38a4e81822378848df9888da5ab22015d9c2412c65b
