Remove Send+Sync bounds on create_raw_function.

Previously there were two different functions for creating raw functions: one
for "host" functions that had the `Send+Sync` bounds and another for "normal"
functions without.

The implementations of both merged into one implementation and the bounds were
kept.

However, as `IntoFunc` isn't bounded with `Send+Sync`, a transmute was made to
ignore the bounds in `create_raw_function`. The comment for the transmute is
now out of date because the implementation is no longer specific to "host"
functions.

This commit removes the bounds from `create_raw_function` and, by extension,
the transmute call.

This change really doesn't alter any safety semantics as `Send+Sync` is
enforced for host functions when they are defined in `Config`.

Author: peterhuene

crates/wasmtime/src/func.rs

@@ -1787,17 +1787,20 @@ macro_rules! impl_into_func {
                 );
 
                 let trampoline = host_trampoline::<$($args,)* R>;
-                let shared_signature_id = registry.map(|r| r.register(ty.as_wasm_func_type(), trampoline)).unwrap_or(VMSharedSignatureIndex::default());
+
+                // If not given a registry, use a default signature index that is guaranteed to trap
+                // if the function is called indirectly without first being associated with a store (a bug condition).
+                let shared_signature_id = registry
+                    .map(|r| r.register(ty.as_wasm_func_type(), trampoline))
+                    .unwrap_or(VMSharedSignatureIndex::default());
 
                 let instance = unsafe {
                     crate::trampoline::create_raw_function(
                         std::slice::from_raw_parts_mut(
                             wasm_to_host_shim::<F, $($args,)* R> as *mut _,
                             0,
                         ),
-                        // This transmutation is safe as the *only* place this should be called is from
-                        // `Config::wrap_host_func` which adds the Send and Sync bounds on the function.
-                        std::mem::transmute::<Box<dyn Any>, _>(Box::new(self)),
+                        Box::new(self),
                         shared_signature_id
                     )
                     .expect("failed to create raw function")

crates/wasmtime/src/trampoline/func.rs

@@ -293,7 +293,7 @@ pub fn create_function(
 
 pub unsafe fn create_raw_function(
     func: *mut [VMFunctionBody],
-    host_state: Box<dyn Any + Send + Sync>,
+    host_state: Box<dyn Any>,
     shared_signature_id: VMSharedSignatureIndex,
 ) -> Result<InstanceHandle> {
     let mut module = Module::new();