allow no-alloc run-time reflection

Author: dwrensha

capnp/src/any_pointer.rs

@@ -46,7 +46,6 @@ impl crate::introspect::Introspect for Owned {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl crate::traits::Pipelined for Owned {
     type Pipeline = Pipeline;
 }
@@ -214,30 +213,38 @@ impl<'a> crate::traits::ImbueMut<'a> for Builder<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 pub struct Pipeline {
     // XXX this should not be public
+    #[cfg(feature = "alloc")]
     pub hook: Box<dyn PipelineHook>,
 
+    #[cfg(feature = "alloc")]
     ops: Vec<PipelineOp>,
 }
 
-#[cfg(feature = "alloc")]
 impl Pipeline {
+    #[cfg(feature = "alloc")]
     pub fn new(hook: Box<dyn PipelineHook>) -> Self {
         Self {
             hook,
             ops: Vec::new(),
         }
     }
 
+    #[cfg(feature = "alloc")]
     pub fn noop(&self) -> Self {
         Self {
             hook: self.hook.add_ref(),
             ops: self.ops.clone(),
         }
     }
 
+    #[cfg(not(feature = "alloc"))]
+    pub fn noop(&self) -> Self {
+        Self {}
+    }
+
+    #[cfg(feature = "alloc")]
     pub fn get_pointer_field(&self, pointer_index: u16) -> Self {
         let mut new_ops = Vec::with_capacity(self.ops.len() + 1);
         for op in &self.ops {
@@ -250,26 +257,29 @@ impl Pipeline {
         }
     }
 
+    #[cfg(not(feature = "alloc"))]
+    pub fn get_pointer_field(&self, _pointer_index: u16) -> Self {
+        Self {}
+    }
+
+    #[cfg(feature = "alloc")]
     pub fn as_cap(&self) -> Box<dyn ClientHook> {
         self.hook.get_pipelined_cap(&self.ops)
     }
 }
 
-#[cfg(feature = "alloc")]
 impl crate::capability::FromTypelessPipeline for Pipeline {
     fn new(typeless: Pipeline) -> Self {
         typeless
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     fn from(a: Reader<'a>) -> crate::dynamic_value::Reader<'a> {
         crate::dynamic_value::Reader::AnyPointer(a)
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Builder<'a>> for crate::dynamic_value::Builder<'a> {
     fn from(a: Builder<'a>) -> crate::dynamic_value::Builder<'a> {
         crate::dynamic_value::Builder::AnyPointer(a)

capnp/src/any_pointer_list.rs

@@ -189,7 +189,6 @@ impl<'a> core::iter::IntoIterator for Reader<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     fn from(t: Reader<'a>) -> crate::dynamic_value::Reader<'a> {
         crate::dynamic_value::Reader::List(crate::dynamic_list::Reader::new(
@@ -199,7 +198,6 @@ impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Builder<'a>> for crate::dynamic_value::Builder<'a> {
     fn from(t: Builder<'a>) -> crate::dynamic_value::Builder<'a> {
         crate::dynamic_value::Builder::List(crate::dynamic_list::Builder::new(

capnp/src/capability.rs

@@ -22,36 +22,48 @@
 //! Hooks for for the RPC system.
 //!
 //! Roughly corresponds to capability.h in the C++ implementation.
-#![cfg(feature = "alloc")]
 
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
+#[cfg(feature = "alloc")]
 use core::future::Future;
+#[cfg(feature = "alloc")]
 use core::marker::{PhantomData, Unpin};
 #[cfg(feature = "rpc_try")]
 use core::ops::Try;
+#[cfg(feature = "alloc")]
 use core::pin::Pin;
+#[cfg(feature = "alloc")]
 use core::task::Poll;
 
+use crate::any_pointer;
+#[cfg(feature = "alloc")]
 use crate::private::capability::{ClientHook, ParamsHook, RequestHook, ResponseHook, ResultsHook};
+#[cfg(feature = "alloc")]
 use crate::traits::{Owned, Pipelined};
-use crate::{any_pointer, Error, MessageSize};
+#[cfg(feature = "alloc")]
+use crate::{Error, MessageSize};
 
 /// A computation that might eventually resolve to a value of type `T` or to an error
 ///  of type `E`. Dropping the promise cancels the computation.
+#[cfg(feature = "alloc")]
 #[must_use = "futures do nothing unless polled"]
 pub struct Promise<T, E> {
     inner: PromiseInner<T, E>,
 }
 
+#[cfg(feature = "alloc")]
 enum PromiseInner<T, E> {
     Immediate(Result<T, E>),
     Deferred(Pin<Box<dyn Future<Output = core::result::Result<T, E>> + 'static>>),
     Empty,
 }
 
 // Allow Promise<T,E> to be Unpin, regardless of whether T and E are.
+#[cfg(feature = "alloc")]
 impl<T, E> Unpin for PromiseInner<T, E> {}
 
+#[cfg(feature = "alloc")]
 impl<T, E> Promise<T, E> {
     pub fn ok(value: T) -> Self {
         Self {
@@ -75,6 +87,7 @@ impl<T, E> Promise<T, E> {
     }
 }
 
+#[cfg(feature = "alloc")]
 impl<T, E> Future for Promise<T, E> {
     type Output = core::result::Result<T, E>;
 
@@ -92,6 +105,7 @@ impl<T, E> Future for Promise<T, E> {
     }
 }
 
+#[cfg(feature = "alloc")]
 #[cfg(feature = "rpc_try")]
 impl<T> std::ops::Try for Promise<T, crate::Error> {
     type Output = Self;
@@ -106,6 +120,7 @@ impl<T> std::ops::Try for Promise<T, crate::Error> {
     }
 }
 
+#[cfg(feature = "alloc")]
 #[cfg(feature = "rpc_try")]
 impl<T> std::ops::FromResidual for Promise<T, crate::Error> {
     fn from_residual(residual: <Self as Try>::Residual) -> Self {
@@ -117,6 +132,7 @@ impl<T> std::ops::FromResidual for Promise<T, crate::Error> {
 }
 
 /// A promise for a result from a method call.
+#[cfg(feature = "alloc")]
 #[must_use]
 pub struct RemotePromise<Results>
 where
@@ -127,11 +143,13 @@ where
 }
 
 /// A response from a method call, as seen by the client.
+#[cfg(feature = "alloc")]
 pub struct Response<Results> {
     pub marker: PhantomData<Results>,
     pub hook: Box<dyn ResponseHook>,
 }
 
+#[cfg(feature = "alloc")]
 impl<Results> Response<Results>
 where
     Results: Pipelined + Owned,
@@ -148,11 +166,13 @@ where
 }
 
 /// A method call that has not been sent yet.
+#[cfg(feature = "alloc")]
 pub struct Request<Params, Results> {
     pub marker: PhantomData<(Params, Results)>,
     pub hook: Box<dyn RequestHook>,
 }
 
+#[cfg(feature = "alloc")]
 impl<Params, Results> Request<Params, Results>
 where
     Params: Owned,
@@ -173,6 +193,7 @@ where
     }
 }
 
+#[cfg(feature = "alloc")]
 impl<Params, Results> Request<Params, Results>
 where
     Results: Pipelined + Owned + 'static + Unpin,
@@ -196,11 +217,13 @@ where
 }
 
 /// The values of the parameters passed to a method call, as seen by the server.
+#[cfg(feature = "alloc")]
 pub struct Params<T> {
     pub marker: PhantomData<T>,
     pub hook: Box<dyn ParamsHook>,
 }
 
+#[cfg(feature = "alloc")]
 impl<T> Params<T> {
     pub fn new(hook: Box<dyn ParamsHook>) -> Self {
         Self {
@@ -217,11 +240,13 @@ impl<T> Params<T> {
 }
 
 /// The return values of a method, written in-place by the method body.
+#[cfg(feature = "alloc")]
 pub struct Results<T> {
     pub marker: PhantomData<T>,
     pub hook: Box<dyn ResultsHook>,
 }
 
+#[cfg(feature = "alloc")]
 impl<T> Results<T>
 where
     T: Owned,
@@ -247,6 +272,7 @@ pub trait FromTypelessPipeline {
 }
 
 /// Trait implemented (via codegen) by all user-defined capability client types.
+#[cfg(feature = "alloc")]
 pub trait FromClientHook {
     /// Wraps a client hook to create a new client.
     fn new(hook: Box<dyn ClientHook>) -> Self;
@@ -269,10 +295,12 @@ pub trait FromClientHook {
 }
 
 /// An untyped client.
+#[cfg(feature = "alloc")]
 pub struct Client {
     pub hook: Box<dyn ClientHook>,
 }
 
+#[cfg(feature = "alloc")]
 impl Client {
     pub fn new(hook: Box<dyn ClientHook>) -> Self {
         Self { hook }
@@ -302,6 +330,7 @@ impl Client {
 }
 
 /// An untyped server.
+#[cfg(feature = "alloc")]
 pub trait Server {
     fn dispatch_call(
         &mut self,
@@ -313,6 +342,7 @@ pub trait Server {
 }
 
 /// Trait to track the relationship between generated Server traits and Client structs.
+#[cfg(feature = "alloc")]
 pub trait FromServer<S>: FromClientHook {
     // Implemented by the generated ServerDispatch struct.
     type Dispatch: Server + 'static + core::ops::DerefMut<Target = S>;
@@ -322,6 +352,7 @@ pub trait FromServer<S>: FromClientHook {
 
 /// Gets the "resolved" version of a capability. One place this is useful is for pre-resolving
 /// the argument to `capnp_rpc::CapabilityServerSet::get_local_server_of_resolved()`.
+#[cfg(feature = "alloc")]
 pub async fn get_resolved_cap<C: FromClientHook>(cap: C) -> C {
     let mut hook = cap.into_client_hook();
     let _ = hook.when_resolved().await;

capnp/src/data.rs

@@ -82,14 +82,12 @@ impl<'a> crate::traits::SetPointerBuilder for Reader<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     fn from(d: Reader<'a>) -> crate::dynamic_value::Reader<'a> {
         crate::dynamic_value::Reader::Data(d)
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Builder<'a>> for crate::dynamic_value::Builder<'a> {
     fn from(d: Builder<'a>) -> crate::dynamic_value::Builder<'a> {
         crate::dynamic_value::Builder::Data(d)

capnp/src/data_list.rs

@@ -199,7 +199,6 @@ impl<'a> ::core::iter::IntoIterator for Reader<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     fn from(t: Reader<'a>) -> crate::dynamic_value::Reader<'a> {
         crate::dynamic_value::Reader::List(crate::dynamic_list::Reader {
@@ -209,7 +208,6 @@ impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a> From<Builder<'a>> for crate::dynamic_value::Builder<'a> {
     fn from(t: Builder<'a>) -> crate::dynamic_value::Builder<'a> {
         crate::dynamic_value::Builder::List(crate::dynamic_list::Builder {

capnp/src/dynamic_list.rs

@@ -1,6 +1,5 @@
 //! Dynamically-typed lists.
 
-#![cfg(feature = "alloc")]
 use crate::dynamic_value;
 use crate::introspect::{Type, TypeVariant};
 use crate::private::layout::{self, PrimitiveElement};

capnp/src/dynamic_struct.rs

@@ -1,6 +1,5 @@
 //! Dynamically-typed structs.
 
-#![cfg(feature = "alloc")]
 use crate::introspect::TypeVariant;
 use crate::private::layout;
 use crate::schema::{Field, StructSchema};

capnp/src/dynamic_value.rs

@@ -1,6 +1,5 @@
 //! Dynamically typed values.
 
-#![cfg(feature = "alloc")]
 use crate::introspect::{self, TypeVariant};
 use crate::schema_capnp::value;
 use crate::Result;

capnp/src/enum_list.rs

@@ -214,7 +214,6 @@ impl<'a, T: TryFrom<u16, Error = NotInSchema>> ::core::iter::IntoIterator for Re
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a, T: TryFrom<u16, Error = NotInSchema> + crate::introspect::Introspect> From<Reader<'a, T>>
     for crate::dynamic_value::Reader<'a>
 {
@@ -226,7 +225,6 @@ impl<'a, T: TryFrom<u16, Error = NotInSchema> + crate::introspect::Introspect> F
     }
 }
 
-#[cfg(feature = "alloc")]
 impl<'a, T: TryFrom<u16, Error = NotInSchema> + crate::introspect::Introspect> From<Builder<'a, T>>
     for crate::dynamic_value::Builder<'a>
 {

capnp/src/introspect.rs

@@ -1,6 +1,5 @@
 //! Traits and types to support run-time type introspection, i.e. reflection.
 
-#[cfg(feature = "alloc")]
 use crate::private::layout::ElementSize;
 
 /// A type that supports reflection. All types that can appear in a Cap'n Proto message
@@ -71,7 +70,6 @@ impl Type {
 
     /// If this type T appears as List(T), then what is the expected
     /// element size of the list?
-    #[cfg(feature = "alloc")]
     pub(crate) fn expected_element_size(&self) -> ElementSize {
         if self.list_count > 0 {
             ElementSize::Pointer