Refactor wasmtime::FuncType to hold a handle to its registered type

Rather than holding a copy of the type directly, it now holds a `RegisteredType`
which internally is

* A `VMSharedTypeIndex` pointing into the engine's types registry.
* An `Arc` handle to the engine's type registry.
* An `Arc` handle to the actual type.

The last exists only to keep it so that accessing a `wasmtime::FuncType`'s
parameters and results fast, avoiding any new locking on call hot paths.

This is helping set the stage for further types and `TypeRegistry` refactors
needed for Wasm GC.

Author: fitzgen

crates/fuzzing/src/oracles.rs

@@ -616,36 +616,34 @@ pub fn table_ops(
         // NB: use `Func::new` so that this can still compile on the old x86
         // backend, where `IntoFunc` isn't implemented for multi-value
         // returns.
-        let func = Func::new(
-            &mut store,
-            FuncType::new(
-                vec![],
-                vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
-            ),
-            {
-                let num_dropped = num_dropped.clone();
-                let expected_drops = expected_drops.clone();
-                let num_gcs = num_gcs.clone();
-                move |mut caller: Caller<'_, StoreLimits>, _params, results| {
-                    log::info!("table_ops: GC");
-                    if num_gcs.fetch_add(1, SeqCst) < MAX_GCS {
-                        caller.gc();
-                    }
+        let func_ty = FuncType::new(
+            store.engine(),
+            vec![],
+            vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
+        );
+        let func = Func::new(&mut store, func_ty, {
+            let num_dropped = num_dropped.clone();
+            let expected_drops = expected_drops.clone();
+            let num_gcs = num_gcs.clone();
+            move |mut caller: Caller<'_, StoreLimits>, _params, results| {
+                log::info!("table_ops: GC");
+                if num_gcs.fetch_add(1, SeqCst) < MAX_GCS {
+                    caller.gc();
+                }
 
-                    let a = ExternRef::new(CountDrops(num_dropped.clone()));
-                    let b = ExternRef::new(CountDrops(num_dropped.clone()));
-                    let c = ExternRef::new(CountDrops(num_dropped.clone()));
+                let a = ExternRef::new(CountDrops(num_dropped.clone()));
+                let b = ExternRef::new(CountDrops(num_dropped.clone()));
+                let c = ExternRef::new(CountDrops(num_dropped.clone()));
 
-                    log::info!("table_ops: make_refs() -> ({:p}, {:p}, {:p})", a, b, c);
+                log::info!("table_ops: make_refs() -> ({:p}, {:p}, {:p})", a, b, c);
 
-                    expected_drops.fetch_add(3, SeqCst);
-                    results[0] = Some(a).into();
-                    results[1] = Some(b).into();
-                    results[2] = Some(c).into();
-                    Ok(())
-                }
-            },
-        );
+                expected_drops.fetch_add(3, SeqCst);
+                results[0] = Some(a).into();
+                results[1] = Some(b).into();
+                results[2] = Some(c).into();
+                Ok(())
+            }
+        });
         linker.define(&store, "", "gc", func).unwrap();
 
         linker
@@ -691,25 +689,23 @@ pub fn table_ops(
         // NB: use `Func::new` so that this can still compile on the old
         // x86 backend, where `IntoFunc` isn't implemented for
         // multi-value returns.
-        let func = Func::new(
-            &mut store,
-            FuncType::new(
-                vec![],
-                vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
-            ),
-            {
-                let num_dropped = num_dropped.clone();
-                let expected_drops = expected_drops.clone();
-                move |_caller, _params, results| {
-                    log::info!("table_ops: make_refs");
-                    expected_drops.fetch_add(3, SeqCst);
-                    results[0] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    results[1] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    results[2] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    Ok(())
-                }
-            },
+        let func_ty = FuncType::new(
+            store.engine(),
+            vec![],
+            vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
         );
+        let func = Func::new(&mut store, func_ty, {
+            let num_dropped = num_dropped.clone();
+            let expected_drops = expected_drops.clone();
+            move |_caller, _params, results| {
+                log::info!("table_ops: make_refs");
+                expected_drops.fetch_add(3, SeqCst);
+                results[0] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
+                results[1] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
+                results[2] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
+                Ok(())
+            }
+        });
         linker.define(&store, "", "make_refs", func).unwrap();
 
         let instance = linker.instantiate(&mut store, &module).unwrap();

crates/fuzzing/src/oracles/dummy.rs

@@ -114,7 +114,7 @@ mod tests {
     #[test]
     fn dummy_function_import() {
         let mut store = store();
-        let func_ty = FuncType::new(vec![ValType::I32], vec![ValType::I64]);
+        let func_ty = FuncType::new(store.engine(), vec![ValType::I32], vec![ValType::I64]);
         let func = dummy_func(&mut store, func_ty.clone());
         assert_eq!(func.ty(&store), func_ty);
     }

crates/wasmtime/src/runtime/component/types.rs

@@ -2,7 +2,7 @@
 
 use crate::component::matching::InstanceType;
 use crate::component::values::{self, Val};
-use crate::{ExternType, FuncType};
+use crate::{Engine, ExternType, FuncType};
 use anyhow::{anyhow, Result};
 use std::fmt;
 use std::mem;
@@ -799,24 +799,30 @@ impl Module {
     }
 
     /// Iterates over imports of the module
-    pub fn imports(&self) -> impl ExactSizeIterator<Item = ((&str, &str), ExternType)> {
+    pub fn imports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = ((&str, &str), ExternType)> + 'a {
         self.0.types[self.0.index]
             .imports
             .iter()
             .map(|((namespace, name), ty)| {
                 (
                     (namespace.as_str(), name.as_str()),
-                    ExternType::from_wasmtime(self.0.types.module_types(), ty),
+                    ExternType::from_wasmtime(engine, self.0.types.module_types(), ty),
                 )
             })
     }
 
     /// Iterates over exports of the module
-    pub fn exports(&self) -> impl ExactSizeIterator<Item = (&str, ExternType)> {
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ExternType)> + 'a {
         self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
             (
                 name.as_str(),
-                ExternType::from_wasmtime(self.0.types.module_types(), ty),
+                ExternType::from_wasmtime(engine, self.0.types.module_types(), ty),
             )
         })
     }
@@ -832,35 +838,45 @@ impl Component {
     }
 
     /// Returns import associated with `name`, if such exists in the component
-    pub fn get_import(&self, name: &str) -> Option<ComponentItem> {
+    pub fn get_import(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
         self.0.types[self.0.index]
             .imports
             .get(name)
-            .map(|ty| ComponentItem::from(ty, &self.0.instance()))
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
     }
 
     /// Iterates over imports of the component
-    pub fn imports(&self) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> {
-        self.0.types[self.0.index]
-            .imports
-            .iter()
-            .map(|(name, ty)| (name.as_str(), ComponentItem::from(ty, &self.0.instance())))
+    pub fn imports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> + 'a {
+        self.0.types[self.0.index].imports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
     }
 
     /// Returns export associated with `name`, if such exists in the component
-    pub fn get_export(&self, name: &str) -> Option<ComponentItem> {
+    pub fn get_export(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
         self.0.types[self.0.index]
             .exports
             .get(name)
-            .map(|ty| ComponentItem::from(ty, &self.0.instance()))
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
     }
 
     /// Iterates over exports of the component
-    pub fn exports(&self) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> {
-        self.0.types[self.0.index]
-            .exports
-            .iter()
-            .map(|(name, ty)| (name.as_str(), ComponentItem::from(ty, &self.0.instance())))
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> + 'a {
+        self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
     }
 }
 
@@ -874,19 +890,24 @@ impl ComponentInstance {
     }
 
     /// Returns export associated with `name`, if such exists in the component instance
-    pub fn get_export(&self, name: &str) -> Option<ComponentItem> {
+    pub fn get_export(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
         self.0.types[self.0.index]
             .exports
             .get(name)
-            .map(|ty| ComponentItem::from(ty, &self.0.instance()))
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
     }
 
     /// Iterates over exports of the component instance
-    pub fn exports(&self) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> {
-        self.0.types[self.0.index]
-            .exports
-            .iter()
-            .map(|(name, ty)| (name.as_str(), ComponentItem::from(ty, &self.0.instance())))
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> {
+        self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
     }
 }
 
@@ -910,7 +931,7 @@ pub enum ComponentItem {
 }
 
 impl ComponentItem {
-    pub(crate) fn from(def: &TypeDef, ty: &InstanceType<'_>) -> Self {
+    pub(crate) fn from(engine: &Engine, def: &TypeDef, ty: &InstanceType<'_>) -> Self {
         match def {
             TypeDef::Component(idx) => Self::Component(Component::from(*idx, ty)),
             TypeDef::ComponentInstance(idx) => {
@@ -920,7 +941,7 @@ impl ComponentItem {
             TypeDef::Interface(iface_ty) => Self::Type(Type::from(iface_ty, ty)),
             TypeDef::Module(idx) => Self::Module(Module::from(*idx, ty)),
             TypeDef::CoreFunc(idx) => {
-                Self::CoreFunc(FuncType::from_wasm_func_type(ty.types[*idx].clone()))
+                Self::CoreFunc(FuncType::from_wasm_func_type(engine, &ty.types[*idx]))
             }
             TypeDef::Resource(idx) => Self::Resource(ty.resources[ty.types[*idx].ty]),
         }