Update the C API for the function types refactor

prtest:full

crates/c-api/src/async.rs

@@ -271,7 +271,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_async_func(
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(linker.linker.engine());
  let module = to_str!(module, module_len);
  let name = to_str!(name, name_len);
  let cb = c_async_callback_to_rust_fn(callback, data, finalizer);

crates/c-api/src/extern.rs

@@ -26,7 +26,7 @@ pub extern "C" fn wasm_extern_kind(e: &wasm_extern_t) -> wasm_externkind_t {
 
 #[no_mangle]
 pub unsafe extern "C" fn wasm_extern_type(e: &wasm_extern_t) -> Box<wasm_externtype_t> {
- Box::new(wasm_externtype_t::new(e.which.ty(&e.store.context())))
+ Box::new(wasm_externtype_t::from_extern_type(e.which.ty(&e.store.context())))
 }
 
 #[no_mangle]
@@ -135,5 +135,5 @@ pub unsafe extern "C" fn wasmtime_extern_type(
  store: CStoreContext<'_>,
  e: &wasmtime_extern_t,
 ) -> Box<wasm_externtype_t> {
- Box::new(wasm_externtype_t::new(e.to_extern().ty(store)))
+ Box::new(wasm_externtype_t::from_extern_type(e.to_extern().ty(store)))
 }

crates/c-api/src/func.rs

@@ -55,7 +55,7 @@ unsafe fn create_function(
  + Sync
  + 'static,
 ) -> Box<wasm_func_t> {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(store.store.context().engine());
  let func = Func::new(
  store.store.context_mut(),
  ty,
@@ -228,7 +228,7 @@ pub unsafe extern "C" fn wasmtime_func_new(
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
  func: &mut Func,
 ) {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(store.engine());
  let cb = c_callback_to_rust_fn(callback, data, finalizer);
  let f = Func::new(store, ty, cb);
  *func = f;
@@ -293,7 +293,7 @@ pub unsafe extern "C" fn wasmtime_func_new_unchecked(
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
  func: &mut Func,
 ) {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(store.engine());
  let cb = c_unchecked_callback_to_rust_fn(callback, data, finalizer);
  *func = Func::new_unchecked(store, ty, cb);
 }

crates/c-api/src/linker.rs

@@ -69,7 +69,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_func(
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(linker.linker.engine());
  let module = to_str!(module, module_len);
  let name = to_str!(name, name_len);
  let cb = crate::func::c_callback_to_rust_fn(callback, data, finalizer);
@@ -88,7 +88,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_func_unchecked(
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
- let ty = ty.ty().ty.clone();
+ let ty = ty.ty().ty(linker.linker.engine());
  let module = to_str!(module, module_len);
  let name = to_str!(name, name_len);
  let cb = crate::func::c_unchecked_callback_to_rust_fn(callback, data, finalizer);

crates/c-api/src/module.rs

@@ -1,6 +1,6 @@
 use crate::{
  handle_result, wasm_byte_vec_t, wasm_engine_t, wasm_exporttype_t, wasm_exporttype_vec_t,
- wasm_importtype_t, wasm_importtype_vec_t, wasm_store_t, wasmtime_error_t,
+ wasm_importtype_t, wasm_importtype_vec_t, wasm_store_t, wasmtime_error_t, CExternType,
 };
 use anyhow::Context;
 use std::ffi::CStr;
@@ -53,7 +53,7 @@ fn fill_exports(module: &Module, out: &mut wasm_exporttype_vec_t) {
  .map(|e| {
  Some(Box::new(wasm_exporttype_t::new(
  e.name().to_owned(),
- e.ty(),
+ CExternType::new(e.ty()),
  )))
  })
  .collect::<Vec<_>>();
@@ -67,7 +67,7 @@ fn fill_imports(module: &Module, out: &mut wasm_importtype_vec_t) {
  Some(Box::new(wasm_importtype_t::new(
  i.module().to_owned(),
  i.name().to_owned(),
- i.ty(),
+ CExternType::new(i.ty()),
  )))
  })
  .collect::<Vec<_>>();

crates/c-api/src/types/export.rs

@@ -1,20 +1,19 @@
-use crate::{wasm_externtype_t, wasm_name_t};
+use crate::{wasm_externtype_t, wasm_name_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::ExternType;
 
 #[repr(C)]
 #[derive(Clone)]
 pub struct wasm_exporttype_t {
  name: String,
- ty: ExternType,
+ ty: CExternType,
  name_cache: OnceCell<wasm_name_t>,
  type_cache: OnceCell<wasm_externtype_t>,
 }
 
 wasmtime_c_api_macros::declare_ty!(wasm_exporttype_t);
 
 impl wasm_exporttype_t {
- pub(crate) fn new(name: String, ty: ExternType) -> wasm_exporttype_t {
+ pub(crate) fn new(name: String, ty: CExternType) -> wasm_exporttype_t {
  wasm_exporttype_t {
  name,
  ty,
@@ -31,7 +30,7 @@ pub extern "C" fn wasm_exporttype_new(
 ) -> Option<Box<wasm_exporttype_t>> {
  let name = name.take();
  let name = String::from_utf8(name).ok()?;
- Some(Box::new(wasm_exporttype_t::new(name, ty.ty())))
+ Some(Box::new(wasm_exporttype_t::new(name, ty.which.clone())))
 }
 
 #[no_mangle]
@@ -43,5 +42,5 @@ pub extern "C" fn wasm_exporttype_name(et: &wasm_exporttype_t) -> &wasm_name_t {
 #[no_mangle]
 pub extern "C" fn wasm_exporttype_type(et: &wasm_exporttype_t) -> &wasm_externtype_t {
  et.type_cache
- .get_or_init(|| wasm_externtype_t::new(et.ty.clone()))
+ .get_or_init(|| wasm_externtype_t::from_cextern_type(et.ty.clone()))
 }

crates/c-api/src/types/extern.rs

@@ -18,6 +18,17 @@ pub(crate) enum CExternType {
  Table(CTableType),
 }
 
+impl CExternType {
+ pub(crate) fn new(ty: ExternType) -> CExternType {
+ match ty {
+ ExternType::Func(f) => CExternType::Func(CFuncType::new(f)),
+ ExternType::Global(f) => CExternType::Global(CGlobalType::new(f)),
+ ExternType::Memory(f) => CExternType::Memory(CMemoryType::new(f)),
+ ExternType::Table(f) => CExternType::Table(CTableType::new(f)),
+ }
+ }
+}
+
 pub type wasm_externkind_t = u8;
 
 pub const WASM_EXTERN_FUNC: wasm_externkind_t = 0;
@@ -26,24 +37,14 @@ pub const WASM_EXTERN_TABLE: wasm_externkind_t = 2;
 pub const WASM_EXTERN_MEMORY: wasm_externkind_t = 3;
 
 impl wasm_externtype_t {
- pub(crate) fn new(ty: ExternType) -> wasm_externtype_t {
+ pub(crate) fn from_extern_type(ty: ExternType) -> wasm_externtype_t {
  wasm_externtype_t {
- which: match ty {
- ExternType::Func(f) => CExternType::Func(CFuncType::new(f)),
- ExternType::Global(f) => CExternType::Global(CGlobalType::new(f)),
- ExternType::Memory(f) => CExternType::Memory(CMemoryType::new(f)),
- ExternType::Table(f) => CExternType::Table(CTableType::new(f)),
- },
+ which: CExternType::new(ty),
  }
  }
 
- pub(crate) fn ty(&self) -> ExternType {
- match &self.which {
- CExternType::Func(f) => ExternType::Func(f.ty.clone()),
- CExternType::Table(f) => ExternType::Table(f.ty.clone()),
- CExternType::Global(f) => ExternType::Global(f.ty.clone()),
- CExternType::Memory(f) => ExternType::Memory(f.ty.clone()),
- }
+ pub(crate) fn from_cextern_type(ty: CExternType) -> wasm_externtype_t {
+ wasm_externtype_t { which: ty }
  }
 }
 

crates/c-api/src/types/func.rs

@@ -1,6 +1,10 @@
 use crate::{wasm_externtype_t, wasm_valtype_t, wasm_valtype_vec_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::FuncType;
+use std::{
+ mem,
+ sync::{Arc, Mutex},
+};
+use wasmtime::{Engine, FuncType, ValType};
 
 #[repr(transparent)]
 #[derive(Clone)]
@@ -10,17 +14,91 @@ pub struct wasm_functype_t {
 
 wasmtime_c_api_macros::declare_ty!(wasm_functype_t);
 
+#[derive(Clone)]
+enum LazyFuncType {
+ Lazy {
+ params: Vec<ValType>,
+ results: Vec<ValType>,
+ },
+ FuncType(FuncType),
+}
+
+impl LazyFuncType {
+ pub(crate) fn force(&mut self, engine: &Engine) -> FuncType {
+ match self {
+ LazyFuncType::FuncType(ty) => ty.clone(),
+ LazyFuncType::Lazy { params, results } => {
+ let params = mem::take(params);
+ let results = mem::take(results);
+ let ty = FuncType::new(engine, params, results);
+ *self = LazyFuncType::FuncType(ty.clone());
+ ty
+ }
+ }
+ }
+
+ fn params(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+ match self {
+ LazyFuncType::Lazy { params, .. } => LazyFuncTypeIter::Lazy(params.iter()),
+ LazyFuncType::FuncType(f) => LazyFuncTypeIter::FuncType(f.params()),
+ }
+ }
+
+ fn results(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+ match self {
+ LazyFuncType::Lazy { results, .. } => LazyFuncTypeIter::Lazy(results.iter()),
+ LazyFuncType::FuncType(f) => LazyFuncTypeIter::FuncType(f.results()),
+ }
+ }
+}
+
+enum LazyFuncTypeIter<'a, T> {
+ Lazy(std::slice::Iter<'a, ValType>),
+ FuncType(T),
+}
+
+impl<'a, T> Iterator for LazyFuncTypeIter<'a, T>
+where
+ T: Iterator<Item = ValType>,
+{
+ type Item = ValType;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ match self {
+ LazyFuncTypeIter::FuncType(i) => i.next(),
+ LazyFuncTypeIter::Lazy(i) => i.next().cloned(),
+ }
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ match self {
+ LazyFuncTypeIter::FuncType(i) => i.size_hint(),
+ LazyFuncTypeIter::Lazy(i) => i.size_hint(),
+ }
+ }
+}
+
+impl<'a, T> ExactSizeIterator for LazyFuncTypeIter<'a, T> where T: ExactSizeIterator<Item = ValType> {}
+
 #[derive(Clone)]
 pub(crate) struct CFuncType {
- pub(crate) ty: FuncType,
+ ty: Arc<Mutex<LazyFuncType>>,
  params_cache: OnceCell<wasm_valtype_vec_t>,
  returns_cache: OnceCell<wasm_valtype_vec_t>,
 }
 
 impl wasm_functype_t {
  pub(crate) fn new(ty: FuncType) -> wasm_functype_t {
  wasm_functype_t {
- ext: wasm_externtype_t::new(ty.into()),
+ ext: wasm_externtype_t::from_extern_type(ty.into()),
+ }
+ }
+
+ pub(crate) fn lazy(params: Vec<ValType>, results: Vec<ValType>) -> wasm_functype_t {
+ wasm_functype_t {
+ ext: wasm_externtype_t::from_cextern_type(CExternType::Func(CFuncType::lazy(
+ params, results,
+ ))),
  }
  }
 
@@ -42,30 +120,50 @@ impl wasm_functype_t {
 impl CFuncType {
  pub(crate) fn new(ty: FuncType) -> CFuncType {
  CFuncType {
- ty,
+ ty: Arc::new(Mutex::new(LazyFuncType::FuncType(ty))),
  params_cache: OnceCell::new(),
  returns_cache: OnceCell::new(),
  }
  }
+
+ pub(crate) fn lazy(params: Vec<ValType>, results: Vec<ValType>) -> CFuncType {
+ CFuncType {
+ ty: Arc::new(Mutex::new(LazyFuncType::Lazy { params, results })),
+ params_cache: OnceCell::new(),
+ returns_cache: OnceCell::new(),
+ }
+ }
+
+ pub(crate) fn ty(&self, engine: &Engine) -> FuncType {
+ let mut ty = self.ty.lock().unwrap();
+ ty.force(engine)
+ }
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_functype_new(
  params: &mut wasm_valtype_vec_t,
  results: &mut wasm_valtype_vec_t,
 ) -> Box<wasm_functype_t> {
- let params = params.take().into_iter().map(|vt| vt.unwrap().ty.clone());
- let results = results.take().into_iter().map(|vt| vt.unwrap().ty.clone());
- let functype = FuncType::new(params, results);
- Box::new(wasm_functype_t::new(functype))
+ let params = params
+ .take()
+ .into_iter()
+ .map(|vt| vt.unwrap().ty.clone())
+ .collect();
+ let results = results
+ .take()
+ .into_iter()
+ .map(|vt| vt.unwrap().ty.clone())
+ .collect();
+ Box::new(wasm_functype_t::lazy(params, results))
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_functype_params(ft: &wasm_functype_t) -> &wasm_valtype_vec_t {
  let ft = ft.ty();
  ft.params_cache.get_or_init(|| {
- ft.ty
-  .params()
+ let ty = ft.ty.lock().unwrap();
+ ty.params()
  .map(|p| Some(Box::new(wasm_valtype_t { ty: p.clone() })))
  .collect::<Vec<_>>()
  .into()
@@ -76,8 +174,8 @@ pub extern "C" fn wasm_functype_params(ft: &wasm_functype_t) -> &wasm_valtype_ve
 pub extern "C" fn wasm_functype_results(ft: &wasm_functype_t) -> &wasm_valtype_vec_t {
  let ft = ft.ty();
  ft.returns_cache.get_or_init(|| {
- ft.ty
-  .results()
+ let ty = ft.ty.lock().unwrap();
+ ty.results()
  .map(|p| Some(Box::new(wasm_valtype_t { ty: p.clone() })))
  .collect::<Vec<_>>()
  .into()

crates/c-api/src/types/global.rs

@@ -24,7 +24,7 @@ pub(crate) struct CGlobalType {
 impl wasm_globaltype_t {
  pub(crate) fn new(ty: GlobalType) -> wasm_globaltype_t {
  wasm_globaltype_t {
- ext: wasm_externtype_t::new(ty.into()),
+ ext: wasm_externtype_t::from_extern_type(ty.into()),
  }
  }