Method new

crates/debugger/src/lib.rs:241–292

Create a new Debugger that attaches to the given Store and runs the given inner body. The debugger is always in one of two states: running or paused. When paused, the holder of this object can invoke `Debuggee::run` to enter the running state. The inner body will run until paused by a debug event. While running, the future returned by either of these methods owns the `Debuggee` and hence no othe

(mut store: Store<T>, inner: F)

    /// When paused, the holder of this object can access the `Store`
    /// indirectly by providing a closure
    pub fn new<F>(mut store: Store<T>, inner: F) -> Debuggee<T>
    where
        F: for<'a> FnOnce(
                &'a mut Store<T>,
            ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>>
            + Send
            + 'static,
    {
        let engine = store.engine().clone();
        let (in_tx, in_rx) = mpsc::channel(1);
        let (out_tx, out_rx) = mpsc::channel(1);
        let interrupt_pending = Arc::new(AtomicBool::new(false));

        let handle = tokio::spawn({
            let interrupt_pending = interrupt_pending.clone();
            async move {
                // Create the handler that's invoked from within the async
                // debug-event callback.
                let out_tx_clone = out_tx.clone();
                let handler = Handler(Arc::new(HandlerInner {
                    in_rx: Mutex::new(in_rx),
                    out_tx,
                    interrupt_pending,
                }));

                // Emulate a breakpoint at startup.
                log::trace!("inner debuggee task: first breakpoint");
                handler
                    .handle(store.as_context_mut(), DebugEvent::Breakpoint)
                    .await;
                log::trace!("inner debuggee task: first breakpoint resumed");

                // Now invoke the actual inner body.
                store.set_debug_handler(handler);
                log::trace!("inner debuggee task: running `inner`");
                let result = inner(&mut store).await;
                log::trace!("inner debuggee task: done with `inner`");
                let _ = out_tx_clone.send(Response::Finished(store)).await;
                result
            }
        });

        Debuggee {
            engine,
            state: DebuggeeState::Initial,
            store: None,
            in_tx,
            out_rx,
            interrupt_pending,
            handle: Some(handle),
        }
    }

    /// Is the inner body done running?
    pub fn is_complete(&self) -> bool {