Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread.

crates/wasi-crypto/src/wiggle_interfaces/symmetric.rs

@@ -7,7 +7,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     // --- secrets_manager
 
     fn symmetric_key_generate_managed(
-        &self,
+        &mut self,
         secrets_manager_handle: guest_types::SecretsManager,
         alg_str: &wiggle::GuestPtr<'_, str>,
         options_handle: &guest_types::OptOptions,
@@ -17,7 +17,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
             guest_types::OptOptions::Some(options_handle) => Some(options_handle),
             guest_types::OptOptions::None => None,
         };
-        Ok(self
+        Ok((&*self)
             .symmetric_key_generate_managed(
                 secrets_manager_handle.into(),
                 alg_str,
@@ -27,7 +27,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     }
 
     fn symmetric_key_store_managed(
-        &self,
+        &mut self,
         secrets_manager_handle: guest_types::SecretsManager,
         symmetric_key_handle: guest_types::SymmetricKey,
         symmetric_key_id_ptr: &wiggle::GuestPtr<'_, u8>,
@@ -36,7 +36,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
         let key_id_buf = &mut *symmetric_key_id_ptr
             .as_array(symmetric_key_id_max_len)
             .as_slice_mut()?;
-        Ok(self.symmetric_key_store_managed(
+        Ok((&*self).symmetric_key_store_managed(
             secrets_manager_handle.into(),
             symmetric_key_handle.into(),
             key_id_buf,
@@ -44,12 +44,12 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     }
 
     fn symmetric_key_replace_managed(
-        &self,
+        &mut self,
         secrets_manager_handle: guest_types::SecretsManager,
         symmetric_key_old_handle: guest_types::SymmetricKey,
         symmetric_key_new_handle: guest_types::SymmetricKey,
     ) -> Result<guest_types::Version, guest_types::CryptoErrno> {
-        Ok(self
+        Ok((&*self)
             .symmetric_key_replace_managed(
                 secrets_manager_handle.into(),
                 symmetric_key_old_handle.into(),
@@ -59,7 +59,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     }
 
     fn symmetric_key_from_id(
-        &self,
+        &mut self,
         secrets_manager_handle: guest_types::SecretsManager,
         symmetric_key_id_ptr: &wiggle::GuestPtr<'_, u8>,
         symmetric_key_id_len: guest_types::Size,
@@ -68,7 +68,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
         let symmetric_key_id = &*symmetric_key_id_ptr
             .as_array(symmetric_key_id_len)
             .as_slice()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_key_from_id(
                 secrets_manager_handle.into(),
                 symmetric_key_id,
@@ -80,7 +80,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     // --- key
 
     fn symmetric_key_generate(
-        &self,
+        &mut self,
         alg_str: &wiggle::GuestPtr<'_, str>,
         options_handle: &guest_types::OptOptions,
     ) -> Result<guest_types::SymmetricKey, guest_types::CryptoErrno> {
@@ -89,33 +89,33 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
             guest_types::OptOptions::Some(options_handle) => Some(options_handle),
             guest_types::OptOptions::None => None,
         };
-        Ok(self
+        Ok((&*self)
             .symmetric_key_generate(alg_str, options_handle.map(Into::into))?
             .into())
     }
 
     fn symmetric_key_import(
-        &self,
+        &mut self,
         alg_str: &wiggle::GuestPtr<'_, str>,
         raw_ptr: &wiggle::GuestPtr<'_, u8>,
         raw_len: guest_types::Size,
     ) -> Result<guest_types::SymmetricKey, guest_types::CryptoErrno> {
         let alg_str = &*alg_str.as_str()?;
         let raw = &*raw_ptr.as_array(raw_len).as_slice()?;
-        Ok(self.symmetric_key_import(alg_str, raw)?.into())
+        Ok((&*self).symmetric_key_import(alg_str, raw)?.into())
     }
 
     fn symmetric_key_export(
-        &self,
+        &mut self,
         symmetric_key_handle: guest_types::SymmetricKey,
     ) -> Result<guest_types::ArrayOutput, guest_types::CryptoErrno> {
-        Ok(self
+        Ok((&*self)
             .symmetric_key_export(symmetric_key_handle.into())?
             .into())
     }
 
     fn symmetric_key_id(
-        &self,
+        &mut self,
         symmetric_key_handle: guest_types::SymmetricKey,
         symmetric_key_id_ptr: &wiggle::GuestPtr<'_, u8>,
         symmetric_key_id_max_len: guest_types::Size,
@@ -123,7 +123,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
         let key_id_buf = &mut *symmetric_key_id_ptr
             .as_array(symmetric_key_id_max_len)
             .as_slice_mut()?;
-        let (key_id, version) = self.symmetric_key_id(symmetric_key_handle.into())?;
+        let (key_id, version) = (&*self).symmetric_key_id(symmetric_key_handle.into())?;
         ensure!(
             key_id.len() <= key_id_buf.len(),
             CryptoError::Overflow.into()
@@ -133,16 +133,16 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     }
 
     fn symmetric_key_close(
-        &self,
+        &mut self,
         key_handle: guest_types::SymmetricKey,
     ) -> Result<(), guest_types::CryptoErrno> {
-        Ok(self.symmetric_key_close(key_handle.into())?)
+        Ok((&*self).symmetric_key_close(key_handle.into())?)
     }
 
     // --- state
 
     fn symmetric_state_open(
-        &self,
+        &mut self,
         alg_str: &wiggle::GuestPtr<'_, str>,
         key_handle: &guest_types::OptSymmetricKey,
         options_handle: &guest_types::OptOptions,
@@ -156,7 +156,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
             guest_types::OptOptions::Some(options_handle) => Some(options_handle),
             guest_types::OptOptions::None => None,
         };
-        Ok(self
+        Ok((&*self)
             .symmetric_state_open(
                 alg_str,
                 key_handle.map(Into::into),
@@ -166,7 +166,7 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     }
 
     fn symmetric_state_options_get(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         name_str: &wiggle::GuestPtr<'_, str>,
         value_ptr: &wiggle::GuestPtr<'_, u8>,
@@ -174,78 +174,78 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
         let name_str: &str = &*name_str.as_str()?;
         let value = &mut *value_ptr.as_array(value_max_len).as_slice_mut()?;
-        Ok(self
+        Ok((&*self)
             .options_get(symmetric_state_handle.into(), name_str, value)?
             .try_into()?)
     }
 
     fn symmetric_state_options_get_u64(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         name_str: &wiggle::GuestPtr<'_, str>,
     ) -> Result<u64, guest_types::CryptoErrno> {
         let name_str: &str = &*name_str.as_str()?;
-        Ok(self.options_get_u64(symmetric_state_handle.into(), name_str)?)
+        Ok((&*self).options_get_u64(symmetric_state_handle.into(), name_str)?)
     }
 
     fn symmetric_state_close(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
     ) -> Result<(), guest_types::CryptoErrno> {
-        Ok(self.symmetric_state_close(symmetric_state_handle.into())?)
+        Ok((&*self).symmetric_state_close(symmetric_state_handle.into())?)
     }
 
     fn symmetric_state_absorb(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         data_ptr: &wiggle::GuestPtr<'_, u8>,
         data_len: guest_types::Size,
     ) -> Result<(), guest_types::CryptoErrno> {
         let data = &*data_ptr.as_array(data_len).as_slice()?;
-        Ok(self.symmetric_state_absorb(symmetric_state_handle.into(), data)?)
+        Ok((&*self).symmetric_state_absorb(symmetric_state_handle.into(), data)?)
     }
 
     fn symmetric_state_squeeze(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         out_ptr: &wiggle::GuestPtr<'_, u8>,
         out_len: guest_types::Size,
     ) -> Result<(), guest_types::CryptoErrno> {
         let out = &mut *out_ptr.as_array(out_len).as_slice_mut()?;
-        Ok(self.symmetric_state_squeeze(symmetric_state_handle.into(), out)?)
+        Ok((&*self).symmetric_state_squeeze(symmetric_state_handle.into(), out)?)
     }
 
     fn symmetric_state_squeeze_tag(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
     ) -> Result<guest_types::SymmetricTag, guest_types::CryptoErrno> {
-        Ok(self
+        Ok((&*self)
             .symmetric_state_squeeze_tag(symmetric_state_handle.into())?
             .into())
     }
 
     fn symmetric_state_squeeze_key(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         alg_str: &wiggle::GuestPtr<'_, str>,
     ) -> Result<guest_types::SymmetricKey, guest_types::CryptoErrno> {
         let alg_str = &*alg_str.as_str()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_state_squeeze_key(symmetric_state_handle.into(), alg_str)?
             .into())
     }
 
     fn symmetric_state_max_tag_len(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
-        Ok(self
+        Ok((&*self)
             .symmetric_state_max_tag_len(symmetric_state_handle.into())?
             .try_into()?)
     }
 
     fn symmetric_state_encrypt(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         out_ptr: &wiggle::GuestPtr<'_, u8>,
         out_len: guest_types::Size,
@@ -254,13 +254,13 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
         let out = &mut *out_ptr.as_array(out_len).as_slice_mut()?;
         let data = &*data_ptr.as_array(data_len).as_slice()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_state_encrypt(symmetric_state_handle.into(), out, data)?
             .try_into()?)
     }
 
     fn symmetric_state_encrypt_detached(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         out_ptr: &wiggle::GuestPtr<'_, u8>,
         out_len: guest_types::Size,
@@ -269,13 +269,13 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     ) -> Result<guest_types::SymmetricTag, guest_types::CryptoErrno> {
         let out = &mut *out_ptr.as_array(out_len).as_slice_mut()?;
         let data = &*data_ptr.as_array(data_len).as_slice()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_state_encrypt_detached(symmetric_state_handle.into(), out, data)?
             .into())
     }
 
     fn symmetric_state_decrypt(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         out_ptr: &wiggle::GuestPtr<'_, u8>,
         out_len: guest_types::Size,
@@ -284,13 +284,13 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
         let out = &mut *out_ptr.as_array(out_len).as_slice_mut()?;
         let data = &*data_ptr.as_array(data_len).as_slice()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_state_decrypt(symmetric_state_handle.into(), out, data)?
             .try_into()?)
     }
 
     fn symmetric_state_decrypt_detached(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
         out_ptr: &wiggle::GuestPtr<'_, u8>,
         out_len: guest_types::Size,
@@ -302,55 +302,55 @@ impl super::wasi_ephemeral_crypto_symmetric::WasiEphemeralCryptoSymmetric for Wa
         let out = &mut *out_ptr.as_array(out_len).as_slice_mut()?;
         let data = &*data_ptr.as_array(data_len).as_slice()?;
         let raw_tag: &[u8] = &*raw_tag_ptr.as_array(raw_tag_len).as_slice()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_state_decrypt_detached(symmetric_state_handle.into(), out, data, raw_tag)?
             .try_into()?)
     }
 
     fn symmetric_state_ratchet(
-        &self,
+        &mut self,
         symmetric_state_handle: guest_types::SymmetricState,
     ) -> Result<(), guest_types::CryptoErrno> {
-        Ok(self.symmetric_state_ratchet(symmetric_state_handle.into())?)
+        Ok((&*self).symmetric_state_ratchet(symmetric_state_handle.into())?)
     }
 
     // --- tag
 
     fn symmetric_tag_len(
-        &self,
+        &mut self,
         symmetric_tag_handle: guest_types::SymmetricTag,
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
-        Ok(self
+        Ok((&*self)
             .symmetric_tag_len(symmetric_tag_handle.into())?
             .try_into()?)
     }
 
     fn symmetric_tag_pull(
-        &self,
+        &mut self,
         symmetric_tag_handle: guest_types::SymmetricTag,
         buf_ptr: &wiggle::GuestPtr<'_, u8>,
         buf_len: guest_types::Size,
     ) -> Result<guest_types::Size, guest_types::CryptoErrno> {
         let buf = &mut *buf_ptr.as_array(buf_len).as_slice_mut()?;
-        Ok(self
+        Ok((&*self)
             .symmetric_tag_pull(symmetric_tag_handle.into(), buf)?
             .try_into()?)
     }
 
     fn symmetric_tag_verify(
-        &self,
+        &mut self,
         symmetric_tag_handle: guest_types::SymmetricTag,
         expected_raw_ptr: &wiggle::GuestPtr<'_, u8>,
         expected_raw_len: guest_types::Size,
     ) -> Result<(), guest_types::CryptoErrno> {
         let expected_raw = &*expected_raw_ptr.as_array(expected_raw_len).as_slice()?;
-        Ok(self.symmetric_tag_verify(symmetric_tag_handle.into(), expected_raw)?)
+        Ok((&*self).symmetric_tag_verify(symmetric_tag_handle.into(), expected_raw)?)
     }
 
     fn symmetric_tag_close(
-        &self,
+        &mut self,
         symmetric_tag_handle: guest_types::SymmetricTag,
     ) -> Result<(), guest_types::CryptoErrno> {
-        Ok(self.symmetric_tag_close(symmetric_tag_handle.into())?)
+        Ok((&*self).symmetric_tag_close(symmetric_tag_handle.into())?)
     }
 }