Don't discard errors in default_value helpers (#10584)

This commit updates the `default_value` helpers added recently to return
a `Result` instead of returning an `Option<T>` and throwing away error
information. This fixes a fuzz bug showing up recently which happened
because the error in question was one we've flagged to ignore, but
because the error was discarded we didn't know to ignore it so it ended
up causing a fuzz failure.

Author: alexcrichton

crates/fuzzing/src/oracles.rs

@@ -1141,9 +1141,9 @@ pub fn call_async(wasm: &[u8], config: &generators::Config, mut poll_amts: &[u32
                 .into()
             }
             other_ty => match other_ty.default_value(&mut store) {
-                Some(item) => item,
-                None => {
-                    log::warn!("couldn't create import for {import:?}");
+                Ok(item) => item,
+                Err(e) => {
+                    log::warn!("couldn't create import for {import:?}: {e:?}");
                     return;
                 }
             },

crates/fuzzing/src/oracles/dummy.rs

@@ -1,16 +1,21 @@
 //! Dummy implementations of things that a Wasm module can import.
 
+use anyhow::Context;
 use wasmtime::*;
 
 /// Create a set of dummy functions/globals/etc for the given imports.
 pub fn dummy_linker<T>(store: &mut Store<T>, module: &Module) -> Result<Linker<T>> {
     let mut linker = Linker::new(store.engine());
     linker.allow_shadowing(true);
     for import in module.imports() {
-        let extern_ = import
-            .ty()
-            .default_value(&mut *store)
-            .ok_or(anyhow::anyhow!("ERROR"))?;
+        let extern_ = import.ty().default_value(&mut *store).with_context(|| {
+            format!(
+                "failed to create dummy value of `{}::{}` - {:?}",
+                import.module(),
+                import.name(),
+                import.ty(),
+            )
+        })?;
         linker
             .define(&store, import.module(), import.name(), extern_)
             .unwrap();

crates/wasmtime/src/runtime/linker.rs

@@ -282,9 +282,17 @@ impl<T> Linker<T> {
         for import in module.imports() {
             if let Err(import_err) = self._get_by_import(&import) {
                 let default_extern =
-                    import_err.ty().default_value(&mut *store).ok_or_else(|| {
-                        anyhow!("no default value exists for type `{:?}`", import_err.ty())
-                    })?;
+                    import_err
+                        .ty()
+                        .default_value(&mut *store)
+                        .with_context(|| {
+                            anyhow!(
+                                "no default value exists for `{}::{}` with type `{:?}`",
+                                import.module(),
+                                import.name(),
+                                import_err.ty(),
+                            )
+                        })?;
                 self.define(
                     store.as_context(),
                     import.module(),

crates/wasmtime/src/runtime/types.rs

@@ -1249,13 +1249,13 @@ impl ExternType {
         }
     }
     /// Construct a default value, if possible for the underlying type. Tags do not have a default value.
-    pub fn default_value(&self, store: impl AsContextMut) -> Option<Extern> {
+    pub fn default_value(&self, store: impl AsContextMut) -> Result<Extern> {
         match self {
             ExternType::Func(func_ty) => func_ty.default_value(store).map(Extern::Func),
             ExternType::Global(global_ty) => global_ty.default_value(store).map(Extern::Global),
             ExternType::Table(table_ty) => table_ty.default_value(store).map(Extern::Table),
             ExternType::Memory(mem_ty) => mem_ty.default_value(store).map(Extern::Memory),
-            ExternType::Tag(_) => None, // FIXME: #10252
+            ExternType::Tag(_) => bail!("default tags not supported yet"), // FIXME: #10252
         }
     }
 }
@@ -2434,12 +2434,13 @@ impl FuncType {
         Self { registered_type }
     }
     /// Construct a func which returns results of default value, if each result type has a default value.
-    pub fn default_value(&self, mut store: impl AsContextMut) -> Option<Func> {
+    pub fn default_value(&self, mut store: impl AsContextMut) -> Result<Func> {
         let dummy_results = self
             .results()
             .map(|ty| ty.default_value())
-            .collect::<Option<Vec<_>>>()?;
-        Some(Func::new(&mut store, self.clone(), move |_, _, results| {
+            .collect::<Option<Vec<_>>>()
+            .ok_or_else(|| anyhow!("function results do not have a default value"))?;
+        Ok(Func::new(&mut store, self.clone(), move |_, _, results| {
             for (slot, dummy) in results.iter_mut().zip(dummy_results.iter()) {
                 *slot = *dummy;
             }
@@ -2502,9 +2503,12 @@ impl GlobalType {
         GlobalType::new(ty, mutability)
     }
     ///
-    pub fn default_value(&self, store: impl AsContextMut) -> Option<RuntimeGlobal> {
-        let val = self.content().default_value()?;
-        RuntimeGlobal::new(store, self.clone(), val).ok()
+    pub fn default_value(&self, store: impl AsContextMut) -> Result<RuntimeGlobal> {
+        let val = self
+            .content()
+            .default_value()
+            .ok_or_else(|| anyhow!("global type has no default value"))?;
+        RuntimeGlobal::new(store, self.clone(), val)
     }
 }
 
@@ -2637,10 +2641,14 @@ impl TableType {
         &self.ty
     }
     ///
-    pub fn default_value(&self, store: impl AsContextMut) -> Option<RuntimeTable> {
+    pub fn default_value(&self, store: impl AsContextMut) -> Result<RuntimeTable> {
         let val: ValType = self.element().clone().into();
-        let init_val = val.default_value()?.ref_()?;
-        RuntimeTable::new(store, self.clone(), init_val).ok()
+        let init_val = val
+            .default_value()
+            .context("table element type does not have a default value")?
+            .ref_()
+            .unwrap();
+        RuntimeTable::new(store, self.clone(), init_val)
     }
 }
 
@@ -2974,8 +2982,8 @@ impl MemoryType {
         &self.ty
     }
     ///
-    pub fn default_value(&self, store: impl AsContextMut) -> Option<RuntimeMemory> {
-        RuntimeMemory::new(store, self.clone()).ok()
+    pub fn default_value(&self, store: impl AsContextMut) -> Result<RuntimeMemory> {
+        RuntimeMemory::new(store, self.clone())
     }
 }