handle remaining redundant import warnings

Author: dwrensha

capnp/src/capability.rs

@@ -23,12 +23,10 @@
 //!
 //! Roughly corresponds to capability.h in the C++ implementation.
 
-#[cfg(feature = "alloc")]
-use alloc::boxed::Box;
 #[cfg(feature = "alloc")]
 use core::future::Future;
 #[cfg(feature = "alloc")]
-use core::marker::{PhantomData, Unpin};
+use core::marker::PhantomData;
 #[cfg(feature = "rpc_try")]
 use core::ops::Try;
 #[cfg(feature = "alloc")]
@@ -55,7 +53,7 @@ pub struct Promise<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>>),
+    Deferred(Pin<alloc::boxed::Box<dyn Future<Output = core::result::Result<T, E>> + 'static>>),
     Empty,
 }
 
@@ -82,7 +80,7 @@ impl<T, E> Promise<T, E> {
         F: Future<Output = core::result::Result<T, E>> + 'static,
     {
         Self {
-            inner: PromiseInner::Deferred(Box::pin(f)),
+            inner: PromiseInner::Deferred(alloc::boxed::Box::pin(f)),
         }
     }
 }
@@ -146,15 +144,15 @@ where
 #[cfg(feature = "alloc")]
 pub struct Response<Results> {
     pub marker: PhantomData<Results>,
-    pub hook: Box<dyn ResponseHook>,
+    pub hook: alloc::boxed::Box<dyn ResponseHook>,
 }
 
 #[cfg(feature = "alloc")]
 impl<Results> Response<Results>
 where
     Results: Pipelined + Owned,
 {
-    pub fn new(hook: Box<dyn ResponseHook>) -> Self {
+    pub fn new(hook: alloc::boxed::Box<dyn ResponseHook>) -> Self {
         Self {
             marker: PhantomData,
             hook,
@@ -169,15 +167,15 @@ where
 #[cfg(feature = "alloc")]
 pub struct Request<Params, Results> {
     pub marker: PhantomData<(Params, Results)>,
-    pub hook: Box<dyn RequestHook>,
+    pub hook: alloc::boxed::Box<dyn RequestHook>,
 }
 
 #[cfg(feature = "alloc")]
 impl<Params, Results> Request<Params, Results>
 where
     Params: Owned,
 {
-    pub fn new(hook: Box<dyn RequestHook>) -> Self {
+    pub fn new(hook: alloc::boxed::Box<dyn RequestHook>) -> Self {
         Self {
             hook,
             marker: PhantomData,
@@ -220,12 +218,12 @@ where
 #[cfg(feature = "alloc")]
 pub struct Params<T> {
     pub marker: PhantomData<T>,
-    pub hook: Box<dyn ParamsHook>,
+    pub hook: alloc::boxed::Box<dyn ParamsHook>,
 }
 
 #[cfg(feature = "alloc")]
 impl<T> Params<T> {
-    pub fn new(hook: Box<dyn ParamsHook>) -> Self {
+    pub fn new(hook: alloc::boxed::Box<dyn ParamsHook>) -> Self {
         Self {
             marker: PhantomData,
             hook,
@@ -243,15 +241,15 @@ impl<T> Params<T> {
 #[cfg(feature = "alloc")]
 pub struct Results<T> {
     pub marker: PhantomData<T>,
-    pub hook: Box<dyn ResultsHook>,
+    pub hook: alloc::boxed::Box<dyn ResultsHook>,
 }
 
 #[cfg(feature = "alloc")]
 impl<T> Results<T>
 where
     T: Owned,
 {
-    pub fn new(hook: Box<dyn ResultsHook>) -> Self {
+    pub fn new(hook: alloc::boxed::Box<dyn ResultsHook>) -> Self {
         Self {
             marker: PhantomData,
             hook,
@@ -275,10 +273,10 @@ pub trait FromTypelessPipeline {
 #[cfg(feature = "alloc")]
 pub trait FromClientHook {
     /// Wraps a client hook to create a new client.
-    fn new(hook: Box<dyn ClientHook>) -> Self;
+    fn new(hook: alloc::boxed::Box<dyn ClientHook>) -> Self;
 
     /// Unwraps client to get the underlying client hook.
-    fn into_client_hook(self) -> Box<dyn ClientHook>;
+    fn into_client_hook(self) -> alloc::boxed::Box<dyn ClientHook>;
 
     /// Gets a reference to the underlying client hook.
     fn as_client_hook(&self) -> &dyn ClientHook;
@@ -297,12 +295,12 @@ pub trait FromClientHook {
 /// An untyped client.
 #[cfg(feature = "alloc")]
 pub struct Client {
-    pub hook: Box<dyn ClientHook>,
+    pub hook: alloc::boxed::Box<dyn ClientHook>,
 }
 
 #[cfg(feature = "alloc")]
 impl Client {
-    pub fn new(hook: Box<dyn ClientHook>) -> Self {
+    pub fn new(hook: alloc::boxed::Box<dyn ClientHook>) -> Self {
         Self { hook }
     }
 

capnp/src/capability_list.rs

@@ -21,7 +21,6 @@
 //! List of capabilities.
 #![cfg(feature = "alloc")]
 
-use alloc::boxed::Box;
 use core::marker::PhantomData;
 
 use crate::capability::FromClientHook;
@@ -182,7 +181,7 @@ where
         }
     }
 
-    pub fn set(&mut self, index: u32, value: Box<dyn ClientHook>) {
+    pub fn set(&mut self, index: u32, value: alloc::boxed::Box<dyn ClientHook>) {
         assert!(index < self.len());
         self.builder
             .reborrow()

capnp/src/message.rs

@@ -68,9 +68,6 @@
 //! }
 //!
 //! ```
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-use core::convert::From;
 
 use crate::any_pointer;
 use crate::private::arena::{BuilderArena, BuilderArenaImpl};
@@ -280,7 +277,7 @@ where
     /// of this message. Works by copying the message twice. For a canonicalization
     /// method that only requires one copy, see `message::Builder::set_root_canonical()`.
     #[cfg(feature = "alloc")]
-    pub fn canonicalize(&self) -> Result<Vec<crate::Word>> {
+    pub fn canonicalize(&self) -> Result<alloc::vec::Vec<crate::Word>> {
         let root = self.get_root_internal()?;
         let size = root.target_size()?.word_count + 1;
         let mut message = Builder::new(HeapAllocator::new().first_segment_words(size as u32));

capnp/src/private/arena.rs

@@ -18,8 +18,6 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
 use core::slice;
 use core::u64;
 
@@ -173,7 +171,7 @@ struct BuilderSegment {
 }
 
 #[cfg(feature = "alloc")]
-type BuilderSegmentArray = Vec<BuilderSegment>;
+type BuilderSegmentArray = alloc::vec::Vec<BuilderSegment>;
 
 #[cfg(not(feature = "alloc"))]
 #[derive(Default)]
@@ -271,7 +269,7 @@ where
         } else {
             #[cfg(feature = "alloc")]
             {
-                let mut v = Vec::with_capacity(reff.segments.len());
+                let mut v = alloc::vec::Vec::with_capacity(reff.segments.len());
                 for seg in &reff.segments {
                     // See safety argument in above branch.
                     let slice = unsafe {

capnp/src/private/capability.rs

@@ -19,9 +19,6 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#![cfg(feature = "alloc")]
-use alloc::boxed::Box;
-
 use crate::any_pointer;
 use crate::capability::{Params, Promise, RemotePromise, Request, Results};
 use crate::MessageSize;
@@ -33,18 +30,18 @@ pub trait ResponseHook {
 pub trait RequestHook {
     fn get(&mut self) -> any_pointer::Builder<'_>;
     fn get_brand(&self) -> usize;
-    fn send(self: Box<Self>) -> RemotePromise<any_pointer::Owned>;
+    fn send(self: alloc::boxed::Box<Self>) -> RemotePromise<any_pointer::Owned>;
     fn tail_send(
-        self: Box<Self>,
+        self: alloc::boxed::Box<Self>,
     ) -> Option<(
         u32,
         crate::capability::Promise<(), crate::Error>,
-        Box<dyn PipelineHook>,
+        alloc::boxed::Box<dyn PipelineHook>,
     )>;
 }
 
 pub trait ClientHook {
-    fn add_ref(&self) -> Box<dyn ClientHook>;
+    fn add_ref(&self) -> alloc::boxed::Box<dyn ClientHook>;
     fn new_call(
         &self,
         interface_id: u64,
@@ -56,8 +53,8 @@ pub trait ClientHook {
         &self,
         interface_id: u64,
         method_id: u16,
-        params: Box<dyn ParamsHook>,
-        results: Box<dyn ResultsHook>,
+        params: alloc::boxed::Box<dyn ParamsHook>,
+        results: alloc::boxed::Box<dyn ResultsHook>,
     ) -> crate::capability::Promise<(), crate::Error>;
 
     /// If this capability is associated with an rpc connection, then this method
@@ -71,21 +68,21 @@ pub trait ClientHook {
     /// of the capability.  The caller may permanently replace this client with the resolved one if
     /// desired.  Returns null if the client isn't a promise or hasn't resolved yet -- use
     /// `whenMoreResolved()` to distinguish between them.
-    fn get_resolved(&self) -> Option<Box<dyn ClientHook>>;
+    fn get_resolved(&self) -> Option<alloc::boxed::Box<dyn ClientHook>>;
 
     /// If this client is a settled reference (not a promise), return nullptr.  Otherwise, return a
     /// promise that eventually resolves to a new client that is closer to being the final, settled
     /// client (i.e. the value eventually returned by `getResolved()`).  Calling this repeatedly
     /// should eventually produce a settled client.
     fn when_more_resolved(
         &self,
-    ) -> Option<crate::capability::Promise<Box<dyn ClientHook>, crate::Error>>;
+    ) -> Option<crate::capability::Promise<alloc::boxed::Box<dyn ClientHook>, crate::Error>>;
 
     /// Repeatedly calls whenMoreResolved() until it returns nullptr.
     fn when_resolved(&self) -> Promise<(), crate::Error>;
 }
 
-impl Clone for Box<dyn ClientHook> {
+impl Clone for alloc::boxed::Box<dyn ClientHook> {
     fn clone(&self) -> Self {
         self.add_ref()
     }
@@ -94,13 +91,16 @@ impl Clone for Box<dyn ClientHook> {
 pub trait ResultsHook {
     fn get(&mut self) -> crate::Result<any_pointer::Builder<'_>>;
     fn allow_cancellation(&self);
-    fn tail_call(self: Box<Self>, request: Box<dyn RequestHook>) -> Promise<(), crate::Error>;
+    fn tail_call(
+        self: alloc::boxed::Box<Self>,
+        request: alloc::boxed::Box<dyn RequestHook>,
+    ) -> Promise<(), crate::Error>;
     fn direct_tail_call(
-        self: Box<Self>,
-        request: Box<dyn RequestHook>,
+        self: alloc::boxed::Box<Self>,
+        request: alloc::boxed::Box<dyn RequestHook>,
     ) -> (
         crate::capability::Promise<(), crate::Error>,
-        Box<dyn PipelineHook>,
+        alloc::boxed::Box<dyn PipelineHook>,
     );
 }
 
@@ -131,17 +131,20 @@ pub fn internal_get_untyped_results<T>(typeful: Results<T>) -> Results<any_point
 }
 
 pub trait PipelineHook {
-    fn add_ref(&self) -> Box<dyn PipelineHook>;
-    fn get_pipelined_cap(&self, ops: &[PipelineOp]) -> Box<dyn ClientHook>;
+    fn add_ref(&self) -> alloc::boxed::Box<dyn PipelineHook>;
+    fn get_pipelined_cap(&self, ops: &[PipelineOp]) -> alloc::boxed::Box<dyn ClientHook>;
 
     /// Version of get_pipelined_cap() passing the array by move. May avoid a copy in some cases.
     /// Default implementation just calls the other version.
-    fn get_pipelined_cap_move(&self, ops: alloc::vec::Vec<PipelineOp>) -> Box<dyn ClientHook> {
+    fn get_pipelined_cap_move(
+        &self,
+        ops: alloc::vec::Vec<PipelineOp>,
+    ) -> alloc::boxed::Box<dyn ClientHook> {
         self.get_pipelined_cap(&ops)
     }
 }
 
-impl Clone for Box<dyn PipelineHook> {
+impl Clone for alloc::boxed::Box<dyn PipelineHook> {
     fn clone(&self) -> Self {
         self.add_ref()
     }