wit-bindgen-cli 0.57.1

CLI tool to generate bindings for WIT documents and the component model. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//@ wasmtime-flags = '-Wcomponent-model-async'

include!(env!("BINDINGS"));

use crate::my::test::i::{read_and_drop, take_then_drop};
use futures::task::noop_waker_ref;
use std::future::Future;
use std::task::Context;
use wit_bindgen::FutureWriteCancel;

struct Component;

export!(Component);

impl Guest for Component {
    async fn run() {
        // cancel from the other end
        let (tx, rx) = wit_future::new(|| unreachable!());
        let f1 = async { tx.write("hello".into()).await };
        let f2 = async { take_then_drop(rx) };
        let (result, ()) = futures::join!(f1, f2);
        assert_eq!(result.unwrap_err().value, "hello");

        // cancel before we actually hit the intrinsic
        let (tx, _rx) = wit_future::new::<String>(|| String::new());
        let mut future = Box::pin(tx.write("hello2".into()));
        let tx = match future.as_mut().cancel() {
            FutureWriteCancel::Cancelled(val, tx) => {
                assert_eq!(val, "hello2");
                tx
            }
            _ => unreachable!(),
        };

        // cancel after we hit the intrinsic
        let mut future = Box::pin(tx.write("hello3".into()));
        assert!(future
            .as_mut()
            .poll(&mut Context::from_waker(noop_waker_ref()))
            .is_pending());
        match future.as_mut().cancel() {
            FutureWriteCancel::Cancelled(val, _) => {
                assert_eq!(val, "hello3");
            }
            _ => unreachable!(),
        };

        // cancel after we hit the intrinsic and then drop the other end
        let (tx, rx) = wit_future::new::<String>(|| unreachable!());
        let mut future = Box::pin(tx.write("hello3".into()));
        assert!(future
            .as_mut()
            .poll(&mut Context::from_waker(noop_waker_ref()))
            .is_pending());
        drop(rx);
        match future.as_mut().cancel() {
            FutureWriteCancel::Dropped(val) => assert_eq!(val, "hello3"),
            other => panic!("expected dropped, got: {other:?}"),
        };

        // Start a write, wait for it to be pending, then go complete the write
        // in some async work, then cancel it and witness that it was written,
        // not cancelled.
        let (tx, rx) = wit_future::new::<String>(|| unreachable!());
        let mut future = Box::pin(tx.write("hello3".into()));
        assert!(future
            .as_mut()
            .poll(&mut Context::from_waker(noop_waker_ref()))
            .is_pending());
        read_and_drop(rx).await;
        match future.as_mut().cancel() {
            FutureWriteCancel::AlreadySent => {}
            other => panic!("expected sent, got: {other:?}"),
        };
    }
}