[INFO] fetching crate spideroak-crypto 0.6.0...
[INFO] testing spideroak-crypto-0.6.0 against beta-2025-10-28 for beta-1.92-2
[INFO] extracting crate spideroak-crypto 0.6.0 into /workspace/builds/worker-1-tc2/source
[INFO] removed /workspace/builds/worker-1-tc2/source/.cargo/config.toml
[INFO] started tweaking crates.io crate spideroak-crypto 0.6.0
[INFO] finished tweaking crates.io crate spideroak-crypto 0.6.0
[INFO] tweaked toml for crates.io crate spideroak-crypto 0.6.0 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate spideroak-crypto 0.6.0 on toolchain beta-2025-10-28
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2025-10-28" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate spideroak-crypto 0.6.0 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" "+beta-2025-10-28" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,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" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-10-28" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 46f41c4a62cfd43a8e58c24fa5c4d95aed5cfafc4a59d1ebfc88ba45873fc17b
[INFO] running `Command { std: "docker" "start" "-a" "46f41c4a62cfd43a8e58c24fa5c4d95aed5cfafc4a59d1ebfc88ba45873fc17b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "46f41c4a62cfd43a8e58c24fa5c4d95aed5cfafc4a59d1ebfc88ba45873fc17b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "46f41c4a62cfd43a8e58c24fa5c4d95aed5cfafc4a59d1ebfc88ba45873fc17b", kill_on_drop: false }`
[INFO] [stdout] 46f41c4a62cfd43a8e58c24fa5c4d95aed5cfafc4a59d1ebfc88ba45873fc17b
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,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" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-10-28" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 706055ff0ef75dcea5aa3173ffa88b9fd813070fae9fdc29aba0bdd11833d722
[INFO] running `Command { std: "docker" "start" "-a" "706055ff0ef75dcea5aa3173ffa88b9fd813070fae9fdc29aba0bdd11833d722", kill_on_drop: false }`
[INFO] [stderr]    Compiling typenum v1.18.0
[INFO] [stderr]    Compiling zeroize v1.8.1
[INFO] [stderr]    Compiling subtle v2.6.1
[INFO] [stderr]    Compiling const-oid v0.9.6
[INFO] [stderr]    Compiling base16ct v0.2.0
[INFO] [stderr]    Compiling zerocopy v0.8.25
[INFO] [stderr]    Compiling thiserror v2.0.12
[INFO] [stderr]    Compiling const-default v1.0.0
[INFO] [stderr]    Compiling generic-array v0.14.7
[INFO] [stderr]    Compiling buggy v0.1.0
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling syn v2.0.101
[INFO] [stderr]    Compiling curve25519-dalek v4.1.3
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling ff v0.13.1
[INFO] [stderr]    Compiling der v0.7.10
[INFO] [stderr]    Compiling group v0.13.0
[INFO] [stderr]    Compiling generic-array v1.2.0
[INFO] [stderr]    Compiling crypto-common v0.1.6
[INFO] [stderr]    Compiling block-buffer v0.10.4
[INFO] [stderr]    Compiling sec1 v0.7.3
[INFO] [stderr]    Compiling crypto-bigint v0.5.5
[INFO] [stderr]    Compiling inout v0.1.4
[INFO] [stderr]    Compiling universal-hash v0.5.1
[INFO] [stderr]    Compiling aead v0.5.2
[INFO] [stderr]    Compiling cipher v0.4.4
[INFO] [stderr]    Compiling digest v0.10.7
[INFO] [stderr]    Compiling polyval v0.6.2
[INFO] [stderr]    Compiling hmac v0.12.1
[INFO] [stderr]    Compiling signature v2.2.0
[INFO] [stderr]    Compiling sha2 v0.10.9
[INFO] [stderr]    Compiling aes v0.8.4
[INFO] [stderr]    Compiling ctr v0.9.2
[INFO] [stderr]    Compiling hkdf v0.12.4
[INFO] [stderr]    Compiling rfc6979 v0.4.0
[INFO] [stderr]    Compiling ghash v0.5.1
[INFO] [stderr]    Compiling ed25519 v2.2.3
[INFO] [stderr]    Compiling aes-gcm v0.10.3
[INFO] [stderr]    Compiling curve25519-dalek-derive v0.1.1
[INFO] [stderr]    Compiling zerocopy-derive v0.8.25
[INFO] [stderr]    Compiling thiserror-impl v2.0.12
[INFO] [stderr]    Compiling spideroak-crypto-derive v0.2.0
[INFO] [stderr]    Compiling elliptic-curve v0.13.8
[INFO] [stderr]    Compiling primeorder v0.13.6
[INFO] [stderr]    Compiling ecdsa v0.16.9
[INFO] [stderr]    Compiling ed25519-dalek v2.1.1
[INFO] [stderr]    Compiling p256 v0.13.2
[INFO] [stderr]    Compiling p384 v0.13.1
[INFO] [stderr]    Compiling sha3-utils v0.5.0
[INFO] [stderr]    Compiling spideroak-crypto v0.6.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 12.08s
[INFO] running `Command { std: "docker" "inspect" "706055ff0ef75dcea5aa3173ffa88b9fd813070fae9fdc29aba0bdd11833d722", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "706055ff0ef75dcea5aa3173ffa88b9fd813070fae9fdc29aba0bdd11833d722", kill_on_drop: false }`
[INFO] [stdout] 706055ff0ef75dcea5aa3173ffa88b9fd813070fae9fdc29aba0bdd11833d722
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,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" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-10-28" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 7a8515e8b035505bcaa3d1843396bf5d2b96a09cee866fc76717a6dfa42bf228
[INFO] running `Command { std: "docker" "start" "-a" "7a8515e8b035505bcaa3d1843396bf5d2b96a09cee866fc76717a6dfa42bf228", kill_on_drop: false }`
[INFO] [stderr]    Compiling spideroak-crypto v0.6.0 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0432]: unresolved import `more_asserts`
[INFO] [stdout]  --> src/test_util/aead.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 | use more_asserts::assert_ge;
[INFO] [stdout]   |     ^^^^^^^^^^^^ use of unresolved module or unlinked crate `more_asserts`
[INFO] [stdout]   |
[INFO] [stdout]   = help: if you wanted to use a crate named `more_asserts`, use `cargo add more_asserts` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `more_asserts`
[INFO] [stdout]  --> src/test_util/kdf.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 | use more_asserts::assert_ge;
[INFO] [stdout]   |     ^^^^^^^^^^^^ use of unresolved module or unlinked crate `more_asserts`
[INFO] [stdout]   |
[INFO] [stdout]   = help: if you wanted to use a crate named `more_asserts`, use `cargo add more_asserts` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde`
[INFO] [stdout]     --> src/oid/mod.rs:1156:9
[INFO] [stdout]      |
[INFO] [stdout] 1156 |     use serde::{
[INFO] [stdout]      |         ^^^^^ use of unresolved module or unlinked crate `serde`
[INFO] [stdout]      |
[INFO] [stdout]      = help: if you wanted to use a crate named `serde`, use `cargo add serde` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `wycheproof`
[INFO] [stdout]   --> src/test_util/vectors.rs:11:5
[INFO] [stdout]    |
[INFO] [stdout] 11 |     self, aead::TestName as AeadTest, ecdh::TestName as EcdhTest, ecdsa::TestName as EcdsaTest,
[INFO] [stdout]    |     ^^^^ no external crate `wycheproof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `serde`
[INFO] [stdout]     --> src/oid/mod.rs:1156:9
[INFO] [stdout]      |
[INFO] [stdout] 1156 |     use serde::{
[INFO] [stdout]      |         ^^^^^ use of unresolved module or unlinked crate `serde`
[INFO] [stdout]      |
[INFO] [stdout]      = help: if you wanted to use a crate named `serde`, use `cargo add serde` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `serde_json`
[INFO] [stdout]   --> src/test_util/vectors.rs:44:9
[INFO] [stdout]    |
[INFO] [stdout] 44 |     use serde_json;
[INFO] [stdout]    |         ^^^^^^^^^^ no external crate `serde_json`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `wycheproof`
[INFO] [stdout]   --> src/test_util/vectors.rs:45:9
[INFO] [stdout]    |
[INFO] [stdout] 45 |     use wycheproof::{ByteString, WycheproofError};
[INFO] [stdout]    |         ^^^^^^^^^^ use of unresolved module or unlinked crate `wycheproof`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `wycheproof`, use `cargo add wycheproof` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout]    --> src/test_util/vectors.rs:184:43
[INFO] [stdout]     |
[INFO] [stdout] 184 |     #[derive(Debug, Clone, Eq, PartialEq, serde_derive::Deserialize)]
[INFO] [stdout]     |                                           ^^^^^^^^^^^^ use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout]    --> src/test_util/vectors.rs:175:43
[INFO] [stdout]     |
[INFO] [stdout] 175 |     #[derive(Debug, Clone, Eq, PartialEq, serde_derive::Deserialize)]
[INFO] [stdout]     |                                           ^^^^^^^^^^^^ use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout]    --> src/test_util/vectors.rs:143:43
[INFO] [stdout]     |
[INFO] [stdout] 143 |     #[derive(Debug, Clone, Eq, PartialEq, serde_derive::Deserialize)]
[INFO] [stdout]     |                                           ^^^^^^^^^^^^ use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde_repr`
[INFO] [stdout]    --> src/test_util/vectors.rs:135:14
[INFO] [stdout]     |
[INFO] [stdout] 135 |     #[derive(serde_repr::Deserialize_repr, Copy, Clone, Debug, Eq, PartialEq)]
[INFO] [stdout]     |              ^^^^^^^^^^ use of unresolved module or unlinked crate `serde_repr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout]    --> src/test_util/vectors.rs:119:43
[INFO] [stdout]     |
[INFO] [stdout] 119 |     #[derive(Clone, Debug, Eq, PartialEq, serde_derive::Deserialize)]
[INFO] [stdout]     |                                           ^^^^^^^^^^^^ use of unresolved module or unlinked crate `serde_derive`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot find attribute `serde` in this scope
[INFO] [stdout]    --> src/test_util/vectors.rs:185:7
[INFO] [stdout]     |
[INFO] [stdout] 185 |     #[serde(deny_unknown_fields)]
[INFO] [stdout]     |       ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot find attribute `serde` in this scope
[INFO] [stdout]    --> src/test_util/vectors.rs:188:11
[INFO] [stdout]     |
[INFO] [stdout] 188 |         #[serde(rename = "L")]
[INFO] [stdout]     |           ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot find attribute `serde` in this scope
[INFO] [stdout]    --> src/test_util/vectors.rs:176:7
[INFO] [stdout]     |
[INFO] [stdout] 176 |     #[serde(deny_unknown_fields)]
[INFO] [stdout]     |       ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot find attribute `serde` in this scope
[INFO] [stdout]    --> src/test_util/vectors.rs:144:7
[INFO] [stdout]     |
[INFO] [stdout] 144 |     #[serde(deny_unknown_fields)]
[INFO] [stdout]     |       ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot find attribute `serde` in this scope
[INFO] [stdout]    --> src/test_util/vectors.rs:170:11
[INFO] [stdout]     |
[INFO] [stdout] 170 |         #[serde(rename = "encryptions")]
[INFO] [stdout]     |           ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1360:45
[INFO] [stdout]      |
[INFO] [stdout] 1360 |                 T: fmt::Debug + PartialEq + Serialize + de::DeserializeOwned,
[INFO] [stdout]      |                                             ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serializer` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1439:10
[INFO] [stdout]      |
[INFO] [stdout] 1439 |     impl Serializer for &mut DummySer {
[INFO] [stdout]      |          ^^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1520:16
[INFO] [stdout]      |
[INFO] [stdout] 1520 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1532:16
[INFO] [stdout]      |
[INFO] [stdout] 1532 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1542:16
[INFO] [stdout]      |
[INFO] [stdout] 1542 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1610:16
[INFO] [stdout]      |
[INFO] [stdout] 1610 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1617:16
[INFO] [stdout]      |
[INFO] [stdout] 1617 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1633:16
[INFO] [stdout]      |
[INFO] [stdout] 1633 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1653:16
[INFO] [stdout]      |
[INFO] [stdout] 1653 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1673:16
[INFO] [stdout]      |
[INFO] [stdout] 1673 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1689:16
[INFO] [stdout]      |
[INFO] [stdout] 1689 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1705:16
[INFO] [stdout]      |
[INFO] [stdout] 1705 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Serialize` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1721:16
[INFO] [stdout]      |
[INFO] [stdout] 1721 |             T: Serialize + ?Sized,
[INFO] [stdout]      |                ^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0405]: cannot find trait `Deserializer` in this scope
[INFO] [stdout]     --> src/oid/mod.rs:1736:15
[INFO] [stdout]      |
[INFO] [stdout] 1736 |     impl<'de> Deserializer<'de> for DummyDe<'de> {
[INFO] [stdout]      |               ^^^^^^^^^^^^ not found in this scope
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1455:54
[INFO] [stdout]      |
[INFO] [stdout] 1455 |         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                      ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1455 -         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1455 +         fn serialize_bytes(self, v: &[u8]) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1455:64
[INFO] [stdout]      |
[INFO] [stdout] 1455 |         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1455 -         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1455 +         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1455 -         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1455 +         fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1459:51
[INFO] [stdout]      |
[INFO] [stdout] 1459 |         fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1459 -         fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1459 +         fn serialize_str(self, v: &str) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1459:61
[INFO] [stdout]      |
[INFO] [stdout] 1459 |         fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1459 -         fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1459 +         fn serialize_str(self, v: &str) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1459 -         fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1459 +         fn serialize_str(self, v: &str) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1463:53
[INFO] [stdout]      |
[INFO] [stdout] 1463 |         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1463 -         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1463 +         fn serialize_bool(self, _v: bool) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1463:63
[INFO] [stdout]      |
[INFO] [stdout] 1463 |         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1463 -         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1463 +         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1463 -         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1463 +         fn serialize_bool(self, _v: bool) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1467:53
[INFO] [stdout]      |
[INFO] [stdout] 1467 |         fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1467 -         fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1467 +         fn serialize_char(self, _v: char) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1467:63
[INFO] [stdout]      |
[INFO] [stdout] 1467 |         fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1467 -         fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1467 +         fn serialize_char(self, _v: char) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1467 -         fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1467 +         fn serialize_char(self, _v: char) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1471:49
[INFO] [stdout]      |
[INFO] [stdout] 1471 |         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                 ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1471 -         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1471 +         fn serialize_i8(self, _v: i8) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1471:59
[INFO] [stdout]      |
[INFO] [stdout] 1471 |         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1471 -         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1471 +         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1471 -         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1471 +         fn serialize_i8(self, _v: i8) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1474:51
[INFO] [stdout]      |
[INFO] [stdout] 1474 |         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1474 -         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1474 +         fn serialize_i16(self, _v: i16) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1474:61
[INFO] [stdout]      |
[INFO] [stdout] 1474 |         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1474 -         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1474 +         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1474 -         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1474 +         fn serialize_i16(self, _v: i16) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1477:51
[INFO] [stdout]      |
[INFO] [stdout] 1477 |         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1477 -         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1477 +         fn serialize_i32(self, _v: i32) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1477:61
[INFO] [stdout]      |
[INFO] [stdout] 1477 |         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1477 -         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1477 +         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1477 -         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1477 +         fn serialize_i32(self, _v: i32) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1480:51
[INFO] [stdout]      |
[INFO] [stdout] 1480 |         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1480 -         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1480 +         fn serialize_i64(self, _v: i64) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1480:61
[INFO] [stdout]      |
[INFO] [stdout] 1480 |         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1480 -         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1480 +         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1480 -         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1480 +         fn serialize_i64(self, _v: i64) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1483:53
[INFO] [stdout]      |
[INFO] [stdout] 1483 |         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1483 -         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1483 +         fn serialize_i128(self, _v: i128) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1483:63
[INFO] [stdout]      |
[INFO] [stdout] 1483 |         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1483 -         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1483 +         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1483 -         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1483 +         fn serialize_i128(self, _v: i128) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1487:49
[INFO] [stdout]      |
[INFO] [stdout] 1487 |         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                 ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1487 -         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1487 +         fn serialize_u8(self, _v: u8) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1487:59
[INFO] [stdout]      |
[INFO] [stdout] 1487 |         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1487 -         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1487 +         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1487 -         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1487 +         fn serialize_u8(self, _v: u8) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1490:51
[INFO] [stdout]      |
[INFO] [stdout] 1490 |         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1490 -         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1490 +         fn serialize_u16(self, _v: u16) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1490:61
[INFO] [stdout]      |
[INFO] [stdout] 1490 |         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1490 -         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1490 +         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1490 -         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1490 +         fn serialize_u16(self, _v: u16) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1493:51
[INFO] [stdout]      |
[INFO] [stdout] 1493 |         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1493 -         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1493 +         fn serialize_u32(self, _v: u32) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1493:61
[INFO] [stdout]      |
[INFO] [stdout] 1493 |         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1493 -         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1493 +         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1493 -         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1493 +         fn serialize_u32(self, _v: u32) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1496:51
[INFO] [stdout]      |
[INFO] [stdout] 1496 |         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1496 -         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1496 +         fn serialize_u64(self, _v: u64) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1496:61
[INFO] [stdout]      |
[INFO] [stdout] 1496 |         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1496 -         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1496 +         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1496 -         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1496 +         fn serialize_u64(self, _v: u64) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1499:53
[INFO] [stdout]      |
[INFO] [stdout] 1499 |         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1499 -         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1499 +         fn serialize_u128(self, _v: u128) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1499:63
[INFO] [stdout]      |
[INFO] [stdout] 1499 |         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1499 -         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1499 +         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1499 -         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1499 +         fn serialize_u128(self, _v: u128) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1503:51
[INFO] [stdout]      |
[INFO] [stdout] 1503 |         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1503 -         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1503 +         fn serialize_f32(self, _v: f32) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1503:61
[INFO] [stdout]      |
[INFO] [stdout] 1503 |         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1503 -         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1503 +         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1503 -         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1503 +         fn serialize_f32(self, _v: f32) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1506:51
[INFO] [stdout]      |
[INFO] [stdout] 1506 |         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1506 -         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1506 +         fn serialize_f64(self, _v: f64) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1506:61
[INFO] [stdout]      |
[INFO] [stdout] 1506 |         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1506 -         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1506 +         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1506 -         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1506 +         fn serialize_f64(self, _v: f64) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1510:63
[INFO] [stdout]      |
[INFO] [stdout] 1510 |         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeMap` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1510 -         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
[INFO] [stdout] 1510 +         fn serialize_map(self, _len: Option<usize>) -> Result<<&mut DummySer as Example>::SerializeMap, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1510:83
[INFO] [stdout]      |
[INFO] [stdout] 1510 |         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1510 -         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
[INFO] [stdout] 1510 +         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1510 -         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
[INFO] [stdout] 1510 +         fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1518:21
[INFO] [stdout]      |
[INFO] [stdout] 1518 |         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1518 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1518 +         ) -> Result<<&mut DummySer as Example>::Ok, Self::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1518:31
[INFO] [stdout]      |
[INFO] [stdout] 1518 |         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1518 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1518 +         ) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1518 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1518 +         ) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1530:21
[INFO] [stdout]      |
[INFO] [stdout] 1530 |         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1530 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1530 +         ) -> Result<<&mut DummySer as Example>::Ok, Self::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1530:31
[INFO] [stdout]      |
[INFO] [stdout] 1530 |         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1530 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1530 +         ) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1530 -         ) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1530 +         ) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1537:43
[INFO] [stdout]      |
[INFO] [stdout] 1537 |         fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1537 -         fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1537 +         fn serialize_none(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1537:53
[INFO] [stdout]      |
[INFO] [stdout] 1537 |         fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1537 -         fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1537 +         fn serialize_none(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1537 -         fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1537 +         fn serialize_none(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1540:58
[INFO] [stdout]      |
[INFO] [stdout] 1540 |         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1540 -         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1540 +         fn serialize_some<T>(self, _value: &T) -> Result<<&mut DummySer as Example>::Ok, Self::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1540:68
[INFO] [stdout]      |
[INFO] [stdout] 1540 |         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1540 -         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1540 +         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1540 -         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
[INFO] [stdout] 1540 +         fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1551:21
[INFO] [stdout]      |
[INFO] [stdout] 1551 |         ) -> Result<Self::SerializeStruct, Self::Error> {
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeStruct` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1551 -         ) -> Result<Self::SerializeStruct, Self::Error> {
[INFO] [stdout] 1551 +         ) -> Result<<&mut DummySer as Example>::SerializeStruct, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1551:44
[INFO] [stdout]      |
[INFO] [stdout] 1551 |         ) -> Result<Self::SerializeStruct, Self::Error> {
[INFO] [stdout]      |                                            ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1551 -         ) -> Result<Self::SerializeStruct, Self::Error> {
[INFO] [stdout] 1551 +         ) -> Result<Self::SerializeStruct, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1551 -         ) -> Result<Self::SerializeStruct, Self::Error> {
[INFO] [stdout] 1551 +         ) -> Result<Self::SerializeStruct, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1560:21
[INFO] [stdout]      |
[INFO] [stdout] 1560 |         ) -> Result<Self::SerializeStructVariant, Self::Error> {
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeStructVariant` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1560 -         ) -> Result<Self::SerializeStructVariant, Self::Error> {
[INFO] [stdout] 1560 +         ) -> Result<<&mut DummySer as Example>::SerializeStructVariant, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1560:51
[INFO] [stdout]      |
[INFO] [stdout] 1560 |         ) -> Result<Self::SerializeStructVariant, Self::Error> {
[INFO] [stdout]      |                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1560 -         ) -> Result<Self::SerializeStructVariant, Self::Error> {
[INFO] [stdout] 1560 +         ) -> Result<Self::SerializeStructVariant, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1560 -         ) -> Result<Self::SerializeStructVariant, Self::Error> {
[INFO] [stdout] 1560 +         ) -> Result<Self::SerializeStructVariant, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1564:63
[INFO] [stdout]      |
[INFO] [stdout] 1564 |         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeSeq` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1564 -         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
[INFO] [stdout] 1564 +         fn serialize_seq(self, _len: Option<usize>) -> Result<<&mut DummySer as Example>::SerializeSeq, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1564:83
[INFO] [stdout]      |
[INFO] [stdout] 1564 |         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1564 -         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
[INFO] [stdout] 1564 +         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1564 -         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
[INFO] [stdout] 1564 +         fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1568:57
[INFO] [stdout]      |
[INFO] [stdout] 1568 |         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeTuple` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1568 -         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
[INFO] [stdout] 1568 +         fn serialize_tuple(self, _len: usize) -> Result<<&mut DummySer as Example>::SerializeTuple, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1568:79
[INFO] [stdout]      |
[INFO] [stdout] 1568 |         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1568 -         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
[INFO] [stdout] 1568 +         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1568 -         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
[INFO] [stdout] 1568 +         fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1575:21
[INFO] [stdout]      |
[INFO] [stdout] 1575 |         ) -> Result<Self::SerializeTupleStruct, Self::Error> {
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeTupleStruct` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1575 -         ) -> Result<Self::SerializeTupleStruct, Self::Error> {
[INFO] [stdout] 1575 +         ) -> Result<<&mut DummySer as Example>::SerializeTupleStruct, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1575:49
[INFO] [stdout]      |
[INFO] [stdout] 1575 |         ) -> Result<Self::SerializeTupleStruct, Self::Error> {
[INFO] [stdout]      |                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1575 -         ) -> Result<Self::SerializeTupleStruct, Self::Error> {
[INFO] [stdout] 1575 +         ) -> Result<Self::SerializeTupleStruct, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1575 -         ) -> Result<Self::SerializeTupleStruct, Self::Error> {
[INFO] [stdout] 1575 +         ) -> Result<Self::SerializeTupleStruct, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1584:21
[INFO] [stdout]      |
[INFO] [stdout] 1584 |         ) -> Result<Self::SerializeTupleVariant, Self::Error> {
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `SerializeTupleVariant` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1584 -         ) -> Result<Self::SerializeTupleVariant, Self::Error> {
[INFO] [stdout] 1584 +         ) -> Result<<&mut DummySer as Example>::SerializeTupleVariant, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1584:50
[INFO] [stdout]      |
[INFO] [stdout] 1584 |         ) -> Result<Self::SerializeTupleVariant, Self::Error> {
[INFO] [stdout]      |                                                  ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1584 -         ) -> Result<Self::SerializeTupleVariant, Self::Error> {
[INFO] [stdout] 1584 +         ) -> Result<Self::SerializeTupleVariant, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1584 -         ) -> Result<Self::SerializeTupleVariant, Self::Error> {
[INFO] [stdout] 1584 +         ) -> Result<Self::SerializeTupleVariant, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1588:43
[INFO] [stdout]      |
[INFO] [stdout] 1588 |         fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1588 -         fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1588 +         fn serialize_unit(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1588:53
[INFO] [stdout]      |
[INFO] [stdout] 1588 |         fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1588 -         fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1588 +         fn serialize_unit(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1588 -         fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1588 +         fn serialize_unit(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1591:71
[INFO] [stdout]      |
[INFO] [stdout] 1591 |         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                                       ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1591 -         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1591 +         fn serialize_unit_struct(self, _name: &'static str) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1591:81
[INFO] [stdout]      |
[INFO] [stdout] 1591 |         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                                                                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1591 -         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1591 +         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1591 -         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1591 +         fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1599:21
[INFO] [stdout]      |
[INFO] [stdout] 1599 |         ) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                     ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1599 -         ) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1599 +         ) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1599:31
[INFO] [stdout]      |
[INFO] [stdout] 1599 |         ) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1599 -         ) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1599 +         ) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1599 -         ) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1599 +         ) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1608:64
[INFO] [stdout]      |
[INFO] [stdout] 1608 |         fn serialize_key<T>(&mut self, _key: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1608 -         fn serialize_key<T>(&mut self, _key: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1608 +         fn serialize_key<T>(&mut self, _key: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1608 -         fn serialize_key<T>(&mut self, _key: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1608 +         fn serialize_key<T>(&mut self, _key: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1615:68
[INFO] [stdout]      |
[INFO] [stdout] 1615 |         fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1615 -         fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1615 +         fn serialize_value<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1615 -         fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1615 +         fn serialize_value<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1622:32
[INFO] [stdout]      |
[INFO] [stdout] 1622 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1622 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1622 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1622:42
[INFO] [stdout]      |
[INFO] [stdout] 1622 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1622 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1622 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1622 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1622 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1631:70
[INFO] [stdout]      |
[INFO] [stdout] 1631 |         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1631 -         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1631 +         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1631 -         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1631 +         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1638:32
[INFO] [stdout]      |
[INFO] [stdout] 1638 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1638 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1638 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1638:42
[INFO] [stdout]      |
[INFO] [stdout] 1638 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1638 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1638 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1638 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1638 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1651:25
[INFO] [stdout]      |
[INFO] [stdout] 1651 |         ) -> Result<(), Self::Error>
[INFO] [stdout]      |                         ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1651 -         ) -> Result<(), Self::Error>
[INFO] [stdout] 1651 +         ) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1651 -         ) -> Result<(), Self::Error>
[INFO] [stdout] 1651 +         ) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1658:32
[INFO] [stdout]      |
[INFO] [stdout] 1658 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1658 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1658 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1658:42
[INFO] [stdout]      |
[INFO] [stdout] 1658 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1658 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1658 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1658 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1658 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1671:25
[INFO] [stdout]      |
[INFO] [stdout] 1671 |         ) -> Result<(), Self::Error>
[INFO] [stdout]      |                         ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1671 -         ) -> Result<(), Self::Error>
[INFO] [stdout] 1671 +         ) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1671 -         ) -> Result<(), Self::Error>
[INFO] [stdout] 1671 +         ) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1678:32
[INFO] [stdout]      |
[INFO] [stdout] 1678 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1678 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1678 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1678:42
[INFO] [stdout]      |
[INFO] [stdout] 1678 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1678 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1678 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1678 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1678 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1687:70
[INFO] [stdout]      |
[INFO] [stdout] 1687 |         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1687 +         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1687 +         fn serialize_element<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1694:32
[INFO] [stdout]      |
[INFO] [stdout] 1694 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1694 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1694:42
[INFO] [stdout]      |
[INFO] [stdout] 1694 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1694 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1694 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1703:68
[INFO] [stdout]      |
[INFO] [stdout] 1703 |         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1703 -         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1703 +         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1703 -         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1703 +         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1710:32
[INFO] [stdout]      |
[INFO] [stdout] 1710 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1710 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1710 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1710:42
[INFO] [stdout]      |
[INFO] [stdout] 1710 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1710 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1710 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1710 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1710 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1719:68
[INFO] [stdout]      |
[INFO] [stdout] 1719 |         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1719 -         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1719 +         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryFrom>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 1719 -         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
[INFO] [stdout] 1719 +         fn serialize_field<T>(&mut self, _value: &T) -> Result<(), <&mut DummySer as TryInto>::Error>
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1726:32
[INFO] [stdout]      |
[INFO] [stdout] 1726 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: if there were a trait named `Example` with associated type `Ok` implemented for `&mut DummySer`, you could use the fully-qualified path
[INFO] [stdout]      |
[INFO] [stdout] 1726 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1726 +         fn end(self) -> Result<<&mut DummySer as Example>::Ok, Self::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1726:42
[INFO] [stdout]      |
[INFO] [stdout] 1726 |         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout]      |                                          ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1726 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1726 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1726 -         fn end(self) -> Result<Self::Ok, Self::Error> {
[INFO] [stdout] 1726 +         fn end(self) -> Result<Self::Ok, <&mut DummySer as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1743:78
[INFO] [stdout]      |
[INFO] [stdout] 1743 |         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1743:85
[INFO] [stdout]      |
[INFO] [stdout] 1743 |         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1743 -         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1743 +         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1743 -         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1743 +         fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1752:76
[INFO] [stdout]      |
[INFO] [stdout] 1752 |         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                            ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1752:83
[INFO] [stdout]      |
[INFO] [stdout] 1752 |         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1752 -         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1752 +         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1752 -         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1752 +         fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1761:77
[INFO] [stdout]      |
[INFO] [stdout] 1761 |         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1761:84
[INFO] [stdout]      |
[INFO] [stdout] 1761 |         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1761 -         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1761 +         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1761 -         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1761 +         fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1768:24
[INFO] [stdout]      |
[INFO] [stdout] 1768 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1768:31
[INFO] [stdout]      |
[INFO] [stdout] 1768 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1768 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1768 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1768 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1768 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1772:80
[INFO] [stdout]      |
[INFO] [stdout] 1772 |         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1772:87
[INFO] [stdout]      |
[INFO] [stdout] 1772 |         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1772 -         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1772 +         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1772 -         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1772 +         fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1776:78
[INFO] [stdout]      |
[INFO] [stdout] 1776 |         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1776:85
[INFO] [stdout]      |
[INFO] [stdout] 1776 |         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1776 -         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1776 +         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1776 -         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1776 +         fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1780:78
[INFO] [stdout]      |
[INFO] [stdout] 1780 |         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1780:85
[INFO] [stdout]      |
[INFO] [stdout] 1780 |         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1780 -         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1780 +         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1780 -         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1780 +         fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1784:76
[INFO] [stdout]      |
[INFO] [stdout] 1784 |         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                            ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1784:83
[INFO] [stdout]      |
[INFO] [stdout] 1784 |         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1784 -         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1784 +         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1784 -         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1784 +         fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1787:77
[INFO] [stdout]      |
[INFO] [stdout] 1787 |         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1787:84
[INFO] [stdout]      |
[INFO] [stdout] 1787 |         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1787 -         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1787 +         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1787 -         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1787 +         fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1790:77
[INFO] [stdout]      |
[INFO] [stdout] 1790 |         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1790:84
[INFO] [stdout]      |
[INFO] [stdout] 1790 |         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1790 -         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1790 +         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1790 -         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1790 +         fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1793:77
[INFO] [stdout]      |
[INFO] [stdout] 1793 |         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1793:84
[INFO] [stdout]      |
[INFO] [stdout] 1793 |         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1793 -         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1793 +         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1793 -         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1793 +         fn deserialize_i64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1796:78
[INFO] [stdout]      |
[INFO] [stdout] 1796 |         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1796:85
[INFO] [stdout]      |
[INFO] [stdout] 1796 |         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1796 -         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1796 +         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1796 -         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1796 +         fn deserialize_i128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1800:76
[INFO] [stdout]      |
[INFO] [stdout] 1800 |         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                            ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1800:83
[INFO] [stdout]      |
[INFO] [stdout] 1800 |         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1800 -         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1800 +         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1800 -         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1800 +         fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1803:77
[INFO] [stdout]      |
[INFO] [stdout] 1803 |         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1803:84
[INFO] [stdout]      |
[INFO] [stdout] 1803 |         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1803 -         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1803 +         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1803 -         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1803 +         fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1806:77
[INFO] [stdout]      |
[INFO] [stdout] 1806 |         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1806:84
[INFO] [stdout]      |
[INFO] [stdout] 1806 |         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1806 +         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1806 +         fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1809:77
[INFO] [stdout]      |
[INFO] [stdout] 1809 |         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1809:84
[INFO] [stdout]      |
[INFO] [stdout] 1809 |         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1809 +         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1809 +         fn deserialize_u64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1812:78
[INFO] [stdout]      |
[INFO] [stdout] 1812 |         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1812:85
[INFO] [stdout]      |
[INFO] [stdout] 1812 |         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1812 -         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1812 +         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1812 -         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1812 +         fn deserialize_u128<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1816:77
[INFO] [stdout]      |
[INFO] [stdout] 1816 |         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1816:84
[INFO] [stdout]      |
[INFO] [stdout] 1816 |         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1816 -         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1816 +         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1816 -         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1816 +         fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1819:77
[INFO] [stdout]      |
[INFO] [stdout] 1819 |         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1819:84
[INFO] [stdout]      |
[INFO] [stdout] 1819 |         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1819 -         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1819 +         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1819 -         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1819 +         fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1823:80
[INFO] [stdout]      |
[INFO] [stdout] 1823 |         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1823:87
[INFO] [stdout]      |
[INFO] [stdout] 1823 |         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1823 -         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1823 +         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1823 -         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1823 +         fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1826:78
[INFO] [stdout]      |
[INFO] [stdout] 1826 |         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                              ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1826:85
[INFO] [stdout]      |
[INFO] [stdout] 1826 |         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                     ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1826 -         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1826 +         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1826 -         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1826 +         fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1833:24
[INFO] [stdout]      |
[INFO] [stdout] 1833 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1833:31
[INFO] [stdout]      |
[INFO] [stdout] 1833 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1833 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1833 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1833 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1833 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1840:24
[INFO] [stdout]      |
[INFO] [stdout] 1840 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1840:31
[INFO] [stdout]      |
[INFO] [stdout] 1840 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1840 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1840 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1840 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1840 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1843:77
[INFO] [stdout]      |
[INFO] [stdout] 1843 |         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1843:84
[INFO] [stdout]      |
[INFO] [stdout] 1843 |         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1843 -         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1843 +         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1843 -         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1843 +         fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1850:24
[INFO] [stdout]      |
[INFO] [stdout] 1850 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1850:31
[INFO] [stdout]      |
[INFO] [stdout] 1850 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1850 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1850 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1850 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1850 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1858:24
[INFO] [stdout]      |
[INFO] [stdout] 1858 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1858:31
[INFO] [stdout]      |
[INFO] [stdout] 1858 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1858 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1858 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1858 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1858 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1862:77
[INFO] [stdout]      |
[INFO] [stdout] 1862 |         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                             ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1862:84
[INFO] [stdout]      |
[INFO] [stdout] 1862 |         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1862 -         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1862 +         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1862 -         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1862 +         fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1870:24
[INFO] [stdout]      |
[INFO] [stdout] 1870 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1870:31
[INFO] [stdout]      |
[INFO] [stdout] 1870 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1870 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1870 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1870 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1870 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1879:24
[INFO] [stdout]      |
[INFO] [stdout] 1879 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1879:31
[INFO] [stdout]      |
[INFO] [stdout] 1879 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1879 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1879 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1879 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1879 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1886:24
[INFO] [stdout]      |
[INFO] [stdout] 1886 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1886:31
[INFO] [stdout]      |
[INFO] [stdout] 1886 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1886 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1886 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1886 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1886 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0220]: associated type `Value` not found for `V`
[INFO] [stdout]     --> src/oid/mod.rs:1893:24
[INFO] [stdout]      |
[INFO] [stdout] 1893 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                        ^^^^^ associated type `Value` not found
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0223]: ambiguous associated type
[INFO] [stdout]     --> src/oid/mod.rs:1893:31
[INFO] [stdout]      |
[INFO] [stdout] 1893 |         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout]      |                               ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout] help: use fully-qualified syntax
[INFO] [stdout]      |
[INFO] [stdout] 1893 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1893 +         ) -> Result<V::Value, <DummyDe<'de> as TryFrom>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 1893 -         ) -> Result<V::Value, Self::Error> {
[INFO] [stdout] 1893 +         ) -> Result<V::Value, <DummyDe<'de> as TryInto>::Error> {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `de`
[INFO] [stdout]     --> src/oid/mod.rs:1360:57
[INFO] [stdout]      |
[INFO] [stdout] 1360 |                 T: fmt::Debug + PartialEq + Serialize + de::DeserializeOwned,
[INFO] [stdout]      |                                                         ^^ use of unresolved module or unlinked crate `de`
[INFO] [stdout]      |
[INFO] [stdout] help: there is a crate or module with a similar name
[INFO] [stdout]      |
[INFO] [stdout] 1360 |                 T: fmt::Debug + PartialEq + Serialize + der::DeserializeOwned,
[INFO] [stdout]      |                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `de`
[INFO] [stdout]     --> src/oid/mod.rs:1428:10
[INFO] [stdout]      |
[INFO] [stdout] 1428 |     impl de::Error for DummyError {
[INFO] [stdout]      |          ^^ use of unresolved module or unlinked crate `de`
[INFO] [stdout]      |
[INFO] [stdout] help: there is a crate or module with a similar name
[INFO] [stdout]      |
[INFO] [stdout] 1428 |     impl der::Error for DummyError {
[INFO] [stdout]      |            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `de`
[INFO] [stdout]     --> src/oid/mod.rs:1746:57
[INFO] [stdout]      |
[INFO] [stdout] 1746 |                 DummyData::Str(_) => Err(<DummyError as de::Error>::custom(
[INFO] [stdout]      |                                                         ^^ use of unresolved module or unlinked crate `de`
[INFO] [stdout]      |
[INFO] [stdout] help: there is a crate or module with a similar name
[INFO] [stdout]      |
[INFO] [stdout] 1746 |                 DummyData::Str(_) => Err(<DummyError as der::Error>::custom(
[INFO] [stdout]      |                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `de`
[INFO] [stdout]     --> src/oid/mod.rs:1755:59
[INFO] [stdout]      |
[INFO] [stdout] 1755 |                 DummyData::Bytes(_) => Err(<DummyError as de::Error>::custom(
[INFO] [stdout]      |                                                           ^^ use of unresolved module or unlinked crate `de`
[INFO] [stdout]      |
[INFO] [stdout] help: there is a crate or module with a similar name
[INFO] [stdout]      |
[INFO] [stdout] 1755 |                 DummyData::Bytes(_) => Err(<DummyError as der::Error>::custom(
[INFO] [stdout]      |                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0220, E0223, E0405, E0432, E0433.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0220`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `spideroak-crypto` (lib test) due to 179 previous errors
[INFO] running `Command { std: "docker" "inspect" "7a8515e8b035505bcaa3d1843396bf5d2b96a09cee866fc76717a6dfa42bf228", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "7a8515e8b035505bcaa3d1843396bf5d2b96a09cee866fc76717a6dfa42bf228", kill_on_drop: false }`
[INFO] [stdout] 7a8515e8b035505bcaa3d1843396bf5d2b96a09cee866fc76717a6dfa42bf228
