refactor: rename consume/take

consume and take were overloaded function names. I've changed them to:

- into_machine
- into_inner (e.g., blockstore -> inner blockstore)
- into_store
- into_call_manager

Otherwise, we have chains like `consume().consume()`.

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

@@ -287,7 +287,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
@@ -303,7 +303,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.
@@ -335,7 +335,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

@@ -45,7 +45,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

@@ -113,7 +113,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

@@ -64,8 +64,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

@@ -287,7 +287,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

@@ -85,7 +85,7 @@ pub trait Machine: 'static {
     }
 
     /// Consumes the machine and returns the owned blockstore.
-    fn consume(self) -> Self::Blockstore;
+    fn into_store(self) -> Self::Blockstore;
 }
 
 /// Execution context supplied to the machine.

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<()>