Merge pull request #476 from filecoin-project/chore/rename-consume

Refactor consume/take

Author: Stebalien

fvm/src/blockstore/buffered.rs

@@ -33,7 +33,7 @@ where
         }
     }
 
-    pub fn consume(self) -> BS {
+    pub fn into_inner(self) -> BS {
         self.base
     }
 }

fvm/src/call_manager/default.rs

@@ -19,7 +19,7 @@ use crate::{account_actor, syscall_error};
 
 /// The default [`CallManager`] implementation.
 #[repr(transparent)]
-pub struct DefaultCallManager<M>(Option<InnerDefaultCallManager<M>>);
+pub struct DefaultCallManager<M>(Option<Box<InnerDefaultCallManager<M>>>);
 
 #[doc(hidden)]
 #[derive(Deref, DerefMut)]
@@ -65,15 +65,15 @@ where
     type Machine = M;
 
     fn new(machine: M, gas_limit: i64, origin: Address, nonce: u64) -> Self {
-        DefaultCallManager(Some(InnerDefaultCallManager {
+        DefaultCallManager(Some(Box::new(InnerDefaultCallManager {
             machine,
             gas_tracker: GasTracker::new(gas_limit, 0),
             origin,
             nonce,
             num_actors_created: 0,
             call_stack_depth: 0,
             backtrace: Backtrace::default(),
-        }))
+        })))
     }
 
     fn send<K>(
@@ -288,7 +288,7 @@ where
                 match kernel.block_create(DAG_CBOR, params) {
                     Ok(id) => id,
                     // This could fail if we pass some global memory limit.
-                    Err(err) => return (Err(err), kernel.take()),
+                    Err(err) => return (Err(err), kernel.into_call_manager()),
                 }
             } else {
                 super::NO_DATA_BLOCK_ID
@@ -316,7 +316,7 @@ where
                 .or_fatal()
             {
                 Ok(ret) => ret,
-                Err(err) => return (Err(err), store.into_data().kernel.take()),
+                Err(err) => return (Err(err), store.into_data().kernel.into_call_manager()),
             };
 
             // From this point on, there are no more syscall errors, only aborts.
@@ -366,7 +366,7 @@ where
 
             let invocation_data = store.into_data();
             let last_error = invocation_data.last_error;
-            let mut cm = invocation_data.kernel.take();
+            let mut cm = invocation_data.kernel.into_call_manager();
 
             // Process the result, updating the backtrace if necessary.
             let ret = match result {

fvm/src/executor/default.rs

@@ -181,7 +181,7 @@ where
 
     /// Consume consumes the executor and returns the Machine. If the Machine had
     /// been poisoned during execution, the Option will be None.
-    pub fn consume(self) -> Option<<K::CallManager as CallManager>::Machine> {
+    pub fn into_machine(self) -> Option<<K::CallManager as CallManager>::Machine> {
         self.0
     }
 

fvm/src/kernel/default.rs

@@ -76,7 +76,7 @@ where
 {
     type CallManager = C;
 
-    fn take(self) -> Self::CallManager
+    fn into_call_manager(self) -> Self::CallManager
     where
         Self: Sized,
     {

fvm/src/kernel/mod.rs

@@ -46,7 +46,7 @@ pub trait Kernel:
     type CallManager: CallManager;
 
     /// Consume the [`Kernel`] and return the underlying [`CallManager`].
-    fn take(self) -> Self::CallManager
+    fn into_call_manager(self) -> Self::CallManager
     where
         Self: Sized;
 

fvm/src/lib.rs

@@ -96,7 +96,7 @@ mod test {
         let mut bs = MemoryBlockstore::default();
         let mut st = StateTree::new(bs, StateTreeVersion::V4).unwrap();
         let root = st.flush().unwrap();
-        bs = st.consume();
+        bs = st.into_store();
 
         // An empty built-in actors manifest.
         let manifest_cid = {

fvm/src/machine/boxed.rs

@@ -60,8 +60,8 @@ impl<M: Machine> Machine for Box<M> {
     }
 
     #[inline(always)]
-    fn consume(self) -> Self::Blockstore {
-        (*self).consume()
+    fn into_store(self) -> Self::Blockstore {
+        (*self).into_store()
     }
 
     #[inline(always)]

fvm/src/machine/default.rs

@@ -272,7 +272,7 @@ where
         Ok(())
     }
 
-    fn consume(self) -> Self::Blockstore {
-        self.state_tree.consume()
+    fn into_store(self) -> Self::Blockstore {
+        self.state_tree.into_store()
     }
 }

fvm/src/machine/mod.rs

@@ -83,7 +83,7 @@ pub trait Machine: 'static {
     }
 
     /// Consumes the machine and returns the owned blockstore.
-    fn consume(self) -> Self::Blockstore;
+    fn into_store(self) -> Self::Blockstore;
 }
 
 /// Network-level settings. Except when testing locally, changing any of these likely requires a

fvm/src/state_tree.rs

@@ -496,8 +496,8 @@ where
     }
 
     /// Consumes this StateTree and returns the Blockstore it owns via the HAMT.
-    pub fn consume(self) -> S {
-        self.hamt.consume()
+    pub fn into_store(self) -> S {
+        self.hamt.into_store()
     }
 
     pub fn for_each<F>(&self, mut f: F) -> anyhow::Result<()>