start trying to implement tail_call() and set_pipeline()

add stub set_pipeline methods

capnp-rpc/src/local.rs

@@ -126,6 +126,14 @@ impl ResultsHook for Results {
         }
     }
 
+    fn set_pipeline(&mut self, pipeline: Box<dyn PipelineHook>) {
+        todo!()
+    }
+
+    fn on_tail_call(&mut self) -> Promise<any_pointer::Pipeline, crate::Error> {
+        todo!()
+    }
+
     fn tail_call(self: Box<Self>, _request: Box<dyn RequestHook>) -> Promise<(), Error> {
         unimplemented!()
     }

capnp-rpc/src/rpc.rs

@@ -2177,6 +2177,7 @@ where
     variant: Option<ResultsVariant>,
     redirect_results: bool,
     answer_id: AnswerId,
+    tail_call_pipeline_fulfiller: Option<oneshot::Sender<any_pointer::Pipeline>>,
     finish_received: Rc<Cell<bool>>,
 }
 
@@ -2240,6 +2241,7 @@ where
                 redirect_results,
                 answer_id,
                 finish_received,
+                tail_call_pipeline_fulfiller: None,
             }),
             results_done_fulfiller: Some(fulfiller),
         }
@@ -2294,8 +2296,18 @@ impl<VatId> ResultsHook for Results<VatId> {
         }
     }
 
-    fn tail_call(self: Box<Self>, _request: Box<dyn RequestHook>) -> Promise<(), Error> {
-        unimplemented!()
+    fn set_pipeline(&mut self, pipeline: Box<dyn PipelineHook>) {
+        todo!()
+    }
+
+    fn on_tail_call(&mut self) -> Promise<any_pointer::Pipeline, crate::Error> {
+        todo!()
+    }
+
+    fn tail_call(self: Box<Self>, request: Box<dyn RequestHook>) -> Promise<(), Error> {
+        let (promise, pipeline) = self.direct_tail_call(request);
+        // TODO somehow send pipeline to tail_call_pipeline_fulfiller
+        promise
     }
 
     fn direct_tail_call(

capnp/src/capability.rs

@@ -247,7 +247,7 @@ pub struct Results<T> {
 #[cfg(feature = "alloc")]
 impl<T> Results<T>
 where
-    T: Owned,
+    T: Owned + Pipelined,
 {
     pub fn new(hook: alloc::boxed::Box<dyn ResultsHook>) -> Self {
         Self {
@@ -263,6 +263,15 @@ where
     pub fn set(&mut self, other: T::Reader<'_>) -> crate::Result<()> {
         self.hook.get().unwrap().set_as(other)
     }
+
+    pub fn set_pipeline(&mut self, pipeline: T::Pipeline) {
+        // How do we get a PipelineHook out of `pipeline`?
+        //self.hook.set_pipeline(pipeline)
+    }
+
+    pub fn tail_call<SubParams>(self, tail_request: Request<SubParams, T>) -> Promise<(), Error> {
+        self.hook.tail_call(tail_request.hook)
+    }
 }
 
 pub trait FromTypelessPipeline {

capnp/src/private/capability.rs

@@ -93,10 +93,20 @@ impl Clone for alloc::boxed::Box<dyn ClientHook> {
 pub trait ResultsHook {
     fn get(&mut self) -> crate::Result<any_pointer::Builder<'_>>;
     fn allow_cancellation(&self);
+
     fn tail_call(
         self: alloc::boxed::Box<Self>,
         request: alloc::boxed::Box<dyn RequestHook>,
-    ) -> Promise<(), crate::Error>;
+    ) -> Promise<(), crate::Error> {
+        let (promise, pipeline) = self.direct_tail_call(request);
+        // TODO somehow send pipeline to tail_call_pipeline_fulfiller
+        promise
+    }
+
+    fn set_pipeline(&mut self, pipeline: Box<dyn PipelineHook>);
+
+    fn on_tail_call(&mut self) -> Promise<any_pointer::Pipeline, crate::Error>;
+
     fn direct_tail_call(
         self: alloc::boxed::Box<Self>,
         request: alloc::boxed::Box<dyn RequestHook>,