[INFO] fetching crate rearch 0.10.1... [INFO] checking rearch-0.10.1 against master#91c0823ee63e793d990bb9fed898dc95b5d6db51 for pr-125384-2 [INFO] extracting crate rearch 0.10.1 into /workspace/builds/worker-5-tc1/source [INFO] validating manifest of crates.io crate rearch 0.10.1 on toolchain 91c0823ee63e793d990bb9fed898dc95b5d6db51 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+91c0823ee63e793d990bb9fed898dc95b5d6db51" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate rearch 0.10.1 [INFO] finished tweaking crates.io crate rearch 0.10.1 [INFO] tweaked toml for crates.io crate rearch 0.10.1 written to /workspace/builds/worker-5-tc1/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+91c0823ee63e793d990bb9fed898dc95b5d6db51" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 27 packages to latest compatible versions [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+91c0823ee63e793d990bb9fed898dc95b5d6db51" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Downloading crates ... [INFO] [stderr] Downloaded rearch-macros v0.6.0 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/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:dff56e7819e73ed36160586b3445e93eb0be776c16704aeeded9c3fb668b2384" "/opt/rustwide/cargo-home/bin/cargo" "+91c0823ee63e793d990bb9fed898dc95b5d6db51" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] dfcaf01009ec45404dc7682f7d1f248fad1112214272997db4416c2923e69408 [INFO] running `Command { std: "docker" "start" "-a" "dfcaf01009ec45404dc7682f7d1f248fad1112214272997db4416c2923e69408", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "dfcaf01009ec45404dc7682f7d1f248fad1112214272997db4416c2923e69408", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "dfcaf01009ec45404dc7682f7d1f248fad1112214272997db4416c2923e69408", kill_on_drop: false }` [INFO] [stdout] dfcaf01009ec45404dc7682f7d1f248fad1112214272997db4416c2923e69408 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/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=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-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:dff56e7819e73ed36160586b3445e93eb0be776c16704aeeded9c3fb668b2384" "/opt/rustwide/cargo-home/bin/cargo" "+91c0823ee63e793d990bb9fed898dc95b5d6db51" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 5c26649cb92e8cff4757c1e360162c1e5c3d05758e03fcd6cea2aea0a01b5eec [INFO] running `Command { std: "docker" "start" "-a" "5c26649cb92e8cff4757c1e360162c1e5c3d05758e03fcd6cea2aea0a01b5eec", kill_on_drop: false }` [INFO] [stderr] Compiling quote v1.0.36 [INFO] [stderr] Compiling syn v2.0.66 [INFO] [stderr] Compiling rearch-macros v0.6.0 [INFO] [stderr] Checking rearch v0.10.1 (/opt/rustwide/workdir) [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.23s [INFO] running `Command { std: "docker" "inspect" "5c26649cb92e8cff4757c1e360162c1e5c3d05758e03fcd6cea2aea0a01b5eec", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "5c26649cb92e8cff4757c1e360162c1e5c3d05758e03fcd6cea2aea0a01b5eec", kill_on_drop: false }` [INFO] [stdout] 5c26649cb92e8cff4757c1e360162c1e5c3d05758e03fcd6cea2aea0a01b5eec [INFO] checking rearch-0.10.1 against try#519d6e23a6cb73c4d0f295f71ad37db8e95c54ab for pr-125384-2 [INFO] extracting crate rearch 0.10.1 into /workspace/builds/worker-5-tc2/source [INFO] validating manifest of crates.io crate rearch 0.10.1 on toolchain 519d6e23a6cb73c4d0f295f71ad37db8e95c54ab [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+519d6e23a6cb73c4d0f295f71ad37db8e95c54ab" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate rearch 0.10.1 [INFO] finished tweaking crates.io crate rearch 0.10.1 [INFO] tweaked toml for crates.io crate rearch 0.10.1 written to /workspace/builds/worker-5-tc2/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+519d6e23a6cb73c4d0f295f71ad37db8e95c54ab" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 27 packages to latest compatible versions [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+519d6e23a6cb73c4d0f295f71ad37db8e95c54ab" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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:dff56e7819e73ed36160586b3445e93eb0be776c16704aeeded9c3fb668b2384" "/opt/rustwide/cargo-home/bin/cargo" "+519d6e23a6cb73c4d0f295f71ad37db8e95c54ab" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] f8079964d17417d7a0a46a65f718ca6b1ed07a3206a7cb8824846cd66359d5b7 [INFO] running `Command { std: "docker" "start" "-a" "f8079964d17417d7a0a46a65f718ca6b1ed07a3206a7cb8824846cd66359d5b7", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "f8079964d17417d7a0a46a65f718ca6b1ed07a3206a7cb8824846cd66359d5b7", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "f8079964d17417d7a0a46a65f718ca6b1ed07a3206a7cb8824846cd66359d5b7", kill_on_drop: false }` [INFO] [stdout] f8079964d17417d7a0a46a65f718ca6b1ed07a3206a7cb8824846cd66359d5b7 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-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:dff56e7819e73ed36160586b3445e93eb0be776c16704aeeded9c3fb668b2384" "/opt/rustwide/cargo-home/bin/cargo" "+519d6e23a6cb73c4d0f295f71ad37db8e95c54ab" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 4fa8b317409f2013b27ee6798dba71eda76fca3143a6c47d85ae8e0615cb86b6 [INFO] running `Command { std: "docker" "start" "-a" "4fa8b317409f2013b27ee6798dba71eda76fca3143a6c47d85ae8e0615cb86b6", kill_on_drop: false }` [INFO] [stderr] Copying to /tmp/fixit [INFO] [stderr] Running `cargo fix --edition` [INFO] [stderr] Migrating Cargo.toml from 2021 edition to 2024 [INFO] [stderr] Compiling quote v1.0.36 [INFO] [stderr] Compiling syn v2.0.66 [INFO] [stderr] Compiling rearch-macros v0.6.0 [INFO] [stderr] Checking rearch v0.10.1 (/tmp/fixit) [INFO] [stderr] Migrating src/lib.rs from 2021 edition to 2024 [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 7.17s [INFO] [stderr] Running `cargo check` to verify 2024 [INFO] [stderr] Checking rearch v0.10.1 (/tmp/fixit) [INFO] [stdout] error[E0657]: `impl Trait` cannot capture higher-ranked lifetime from outer `impl Trait` [INFO] [stdout] --> src/lib.rs:514:52 [INFO] [stdout] | [INFO] [stdout] 514 | ) -> impl for<'a> SideEffect = (T, impl CData + Fn(T))> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ `impl Trait` implicitly captures all lifetimes in scope [INFO] [stdout] | [INFO] [stdout] note: lifetime declared here [INFO] [stdout] --> src/lib.rs:514:23 [INFO] [stdout] | [INFO] [stdout] 514 | ) -> impl for<'a> SideEffect = (T, impl CData + Fn(T))> { [INFO] [stdout] | ^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0657]: `impl Trait` cannot capture higher-ranked lifetime from outer `impl Trait` [INFO] [stdout] --> src/lib.rs:533:65 [INFO] [stdout] | [INFO] [stdout] 533 | pub fn rebuilder() -> impl for<'a> SideEffect = impl CData + Fn()> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ `impl Trait` implicitly captures all lifetimes in scope [INFO] [stdout] | [INFO] [stdout] note: lifetime declared here [INFO] [stdout] --> src/lib.rs:533:40 [INFO] [stdout] | [INFO] [stdout] 533 | pub fn rebuilder() -> impl for<'a> SideEffect = impl CData + Fn()> { [INFO] [stdout] | ^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: lifetime may not live long enough [INFO] [stdout] --> src/lib.rs:520:17 [INFO] [stdout] | [INFO] [stdout] 515 | move |register: SideEffectRegistrar| { [INFO] [stdout] | -------- - return type of closure `(T, {closure@src/lib.rs:517:33: 517:49})` contains a lifetime `'2` [INFO] [stdout] | | [INFO] [stdout] | has type `side_effect_registrar::SideEffectRegistrar<'1>` [INFO] [stdout] ... [INFO] [stdout] 520 | (state.clone(), set_state) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: lifetime may not live long enough [INFO] [stdout] --> src/lib.rs:536:17 [INFO] [stdout] | [INFO] [stdout] 534 | move |register: SideEffectRegistrar| { [INFO] [stdout] | -------- - return type of closure `{closure@src/lib.rs:536:17: 536:24}` contains a lifetime `'2` [INFO] [stdout] | | [INFO] [stdout] | has type `side_effect_registrar::SideEffectRegistrar<'1>` [INFO] [stdout] 535 | let ((), rebuild, _) = register.raw(()); [INFO] [stdout] 536 | move || rebuild(Box::new(|()| {})) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the trait bound `(for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}, for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> u8 {dependent}): read_capsules::CapsulesWithCloneRead` is not satisfied [INFO] [stdout] --> src/lib.rs:604:65 [INFO] [stdout] | [INFO] [stdout] 604 | let ((state, set_state), plus_one) = container.read((stateful, dependent)); [INFO] [stdout] | ---- ^^^^^^^^^^^^^^^^^^^^^ the trait `read_capsules::CapsulesWithCloneRead` is not implemented for `(fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful}, fn(...) -> ... {dependent})` [INFO] [stdout] | | [INFO] [stdout] | required by a bound introduced by this call [INFO] [stdout] | [INFO] [stdout] = help: the following other types implement trait `read_capsules::CapsulesWithCloneRead`: [INFO] [stdout] (A, B) [INFO] [stdout] (A, B, C) [INFO] [stdout] (A, B, C, D) [INFO] [stdout] (A, B, C, D, E) [INFO] [stdout] (A, B, C, D, E, F) [INFO] [stdout] (A, B, C, D, E, F, G) [INFO] [stdout] (A, B, C, D, E, F, G, H) [INFO] [stdout] note: required by a bound in `Container::read` [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Container::read` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the trait bound `(for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}, for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> u8 {dependent}): read_capsules::CapsulesWithCloneRead` is not satisfied [INFO] [stdout] --> src/lib.rs:609:57 [INFO] [stdout] | [INFO] [stdout] 609 | let ((state, _), plus_one) = container.read((stateful, dependent)); [INFO] [stdout] | ---- ^^^^^^^^^^^^^^^^^^^^^ the trait `read_capsules::CapsulesWithCloneRead` is not implemented for `(fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful}, fn(...) -> ... {dependent})` [INFO] [stdout] | | [INFO] [stdout] | required by a bound introduced by this call [INFO] [stdout] | [INFO] [stdout] = help: the following other types implement trait `read_capsules::CapsulesWithCloneRead`: [INFO] [stdout] (A, B) [INFO] [stdout] (A, B, C) [INFO] [stdout] (A, B, C, D) [INFO] [stdout] (A, B, C, D, E) [INFO] [stdout] (A, B, C, D, E, F) [INFO] [stdout] (A, B, C, D, E, F, G) [INFO] [stdout] (A, B, C, D, E, F, G, H) [INFO] [stdout] note: required by a bound in `Container::read` [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Container::read` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:814:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 814 | assert_eq!(get_build_count(stateful), 1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:821:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 821 | assert_eq!(get_build_count(stateful), 2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:829:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 829 | assert_eq!(get_build_count(stateful), 2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:836:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 836 | assert_eq!(get_build_count(stateful), 3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:844:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 844 | assert_eq!(get_build_count(stateful), 3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:854:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 854 | assert_eq!(get_build_count(stateful), 4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:862:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 862 | assert_eq!(get_build_count(stateful), 4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: aborting due to 261 previous errors [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] Some errors have detailed explanations: E0277, E0308, E0657. [INFO] [stdout] [INFO] [stdout] For more information about an error, try `rustc --explain E0277`. [INFO] [stdout] [INFO] [stderr] error: could not compile `rearch` (lib test) due to 262 previous errors [INFO] [stderr] error: failed to check after updating to 2024 [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] process didn't exit successfully: `cargo check --frozen --all --all-targets --message-format=json` (exit status: 101) [INFO] running `Command { std: "docker" "inspect" "4fa8b317409f2013b27ee6798dba71eda76fca3143a6c47d85ae8e0615cb86b6", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "4fa8b317409f2013b27ee6798dba71eda76fca3143a6c47d85ae8e0615cb86b6", kill_on_drop: false }` [INFO] [stdout] 4fa8b317409f2013b27ee6798dba71eda76fca3143a6c47d85ae8e0615cb86b6