A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Remove a module-linking related api in `wasmtime::Linker` (#13986)
Alex Crichtonb52efaadb9e5
diff --git a/crates/fuzzing/tests/oom/linker.rs b/crates/fuzzing/tests/oom/linker.rsindex a8d527902e..e04c238331 100644--- a/crates/fuzzing/tests/oom/linker.rs+++ b/crates/fuzzing/tests/oom/linker.rs@@ -251,22 +251,6 @@ fn linker_get_default() -> Result<()> {})}-#[test]-fn linker_define_name() -> Result<()> {- let mut config = Config::new();- config.enable_compiler(false);- config.concurrency_support(false);- let engine = Engine::new(&config)?;-- OomTest::new().test(|| {- let mut store = Store::try_new(&engine, ())?;- let mut linker = Linker::<()>::new(&engine);- let func = Func::try_wrap(&mut store, || {})?;- linker.define_name(&store, "func", func)?;- Ok(())- })-}-#[tokio::test]async fn linker_module_async() -> Result<()> {let module_bytes = {diff --git a/crates/wasmtime/src/runtime/linker.rs b/crates/wasmtime/src/runtime/linker.rsindex 2ab5d83554..11a0448dc8 100644--- a/crates/wasmtime/src/runtime/linker.rs+++ b/crates/wasmtime/src/runtime/linker.rs@@ -112,7 +112,7 @@ impl<T> Clone for Linker<T> {#[derive(Copy, Clone, Hash, PartialEq, Eq)]struct ImportKey {module: Atom,- name: Option<Atom>,+ name: Atom,}impl TryClone for ImportKey {@@ -370,34 +370,7 @@ impl<T> Linker<T> {T: 'static,{let store = store.as_context();- let key = self.import_key(module, Some(name))?;- self.insert(key, Definition::new(store.0, item.into()))?;- Ok(self)- }-- /// Same as [`Linker::define`], except only the name of the import is- /// provided, not a module name as well.- ///- /// This is only relevant when working with the module linking proposal- /// where one-level names are allowed (in addition to two-level names).- /// Otherwise this method need not be used.- ///- /// # Errors- ///- /// This function will return an [`OutOfMemory`][crate::OutOfMemory] error when- /// memory allocation fails. See the `OutOfMemory` type's documentation for- /// details on Wasmtime's out-of-memory handling.- pub fn define_name(- &mut self,- store: impl AsContext<Data = T>,- name: &str,- item: impl Into<Extern>,- ) -> Result<&mut Self>- where- T: 'static,- {- let store = store.as_context();- let key = self.import_key(name, None)?;+ let key = self.import_key(module, name)?;self.insert(key, Definition::new(store.0, item.into()))?;Ok(self)}@@ -406,7 +379,7 @@ impl<T> Linker<T> {whereT: 'static,{- let key = self.import_key(module, Some(name))?;+ let key = self.import_key(module, name)?;self.insert(key, Definition::HostFunc(try_new(func)?))?;Ok(self)}@@ -659,12 +632,7 @@ impl<T> Linker<T> {let mut store = store.as_context_mut();let exports: TryVec<_> = instance.exports(&mut store)- .map(|e| {- Ok((- self.import_key(module_name, Some(e.name()))?,- e.into_extern(),- ))- })+ .map(|e| Ok((self.import_key(module_name, e.name())?, e.into_extern()))).try_collect::<_, Error>()?;for (key, export) in exports {self.insert(key, Definition::new(store.0, export))?;@@ -943,7 +911,7 @@ impl<T> Linker<T> {let instance_pre = self.instantiate_pre(module)?;let export_name = export.name().to_owned();let func = mk_func(&mut store, func_ty, export_name, instance_pre);- let key = self.import_key(module_name, Some(export.name()))?;+ let key = self.import_key(module_name, export.name())?;self.insert(key, Definition::new(store.0, func.into()))?;} else if export.name() == "memory" && export.ty().memory().is_some() {// Allow an exported "memory" memory for now.@@ -1001,8 +969,8 @@ impl<T> Linker<T> {as_module: &str,as_name: &str,) -> Result<&mut Self> {- let src = self.import_key(module, Some(name))?;- let dst = self.import_key(as_module, Some(as_name))?;+ let src = self.import_key(module, name)?;+ let dst = self.import_key(as_module, as_name)?;match self.map.get(&src).cloned() {Some(item) => self.insert(dst, item)?,None => bail!("no item named `{module}::{name}` defined"),@@ -1047,20 +1015,18 @@ impl<T> Linker<T> {fn insert(&mut self, key: ImportKey, item: Definition) -> Result<()> {if !self.allow_shadowing && self.map.contains_key(&key) {let module = &self.pool[key.module];- match key.name.and_then(|n| self.pool.get(n)) {- Some(name) => bail!("import of `{module}::{name}` defined twice"),- None => bail!("import of `{module}` defined twice"),- }+ let name = &self.pool[key.name];+ bail!("import of `{module}::{name}` defined twice");}self.map.insert(key, item)?;Ok(())}- fn import_key(&mut self, module: &str, name: Option<&str>) -> Result<ImportKey, OutOfMemory> {+ fn import_key(&mut self, module: &str, name: &str) -> Result<ImportKey, OutOfMemory> {Ok(ImportKey {module: self.pool.insert(module)?,- name: name.map(|name| self.pool.insert(name)).transpose()?,+ name: self.pool.insert(name)?,})}@@ -1262,7 +1228,7 @@ impl<T> Linker<T> {let store = store.as_context_mut();(&self.pool[key.module],- &self.pool[key.name.unwrap()],+ &self.pool[key.name],// Should be safe since `T` is connecting the linker and storeunsafe { item.to_extern(store.0).panic_on_oom() },)@@ -1305,7 +1271,7 @@ impl<T> Linker<T> {fn _get(&self, module: &str, name: &str) -> Option<&Definition> {let key = ImportKey {module: self.pool.get_atom(module)?,- name: Some(self.pool.get_atom(name)?),+ name: self.pool.get_atom(name)?,};self.map.get(&key)}diff --git a/crates/wizer/tests/all/tests.rs b/crates/wizer/tests/all/tests.rsindex b4942932b4..75a59eade5 100644--- a/crates/wizer/tests/all/tests.rs+++ b/crates/wizer/tests/all/tests.rs@@ -65,9 +65,7 @@ async fn wizen_and_run_wasm(let mut linker = wasmtime::Linker::new(store.engine());let thunk = wasmtime::Func::wrap(&mut store, || {});linker- .define_name(&mut store, "dummy_func", thunk)?.define(&mut store, "env", "f", thunk)?- .define_name(&mut store, "f", thunk)?.define(&mut store, "x", "f", thunk)?;p1::add_to_linker_async(&mut linker, |wasi| wasi)?;