A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Change `{Memory,Table}Type::new` to return `Result` (#14591)
Alex Crichtonddf01e51152c
diff --git a/crates/c-api/include/doc-wasm.h b/crates/c-api/include/doc-wasm.hindex 4a92d15d77..24c3e283ed 100644--- a/crates/c-api/include/doc-wasm.h+++ b/crates/c-api/include/doc-wasm.h@@ -510,6 +510,9 @@* This function takes ownership of the #wasm_valtype_t argument, but does not* take ownership of the #wasm_limits_t.*+ * Returns `NULL` if the value type is not a reference type or if the limits+ * are invalid (e.g. the minimum is greater than the maximum).+ ** The caller is responsible for deallocating the returned type.** \fn const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t *);@@ -596,6 +599,9 @@* This function takes ownership of the #wasm_valtype_t argument, but does not* take ownership of the #wasm_limits_t.*+ * Returns `NULL` if the limits are invalid (e.g. the minimum is greater than+ * the maximum or the limits exceed the 32-bit address space).+ ** The caller is responsible for deallocating the returned type.** For compatibility with memory64 it's recommended to usediff --git a/crates/c-api/src/types/memory.rs b/crates/c-api/src/types/memory.rsindex 663fdd6b6e..f0b0929e75 100644--- a/crates/c-api/src/types/memory.rs+++ b/crates/c-api/src/types/memory.rs@@ -49,11 +49,9 @@ impl CMemoryType {}#[unsafe(no_mangle)]-pub extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Box<wasm_memorytype_t> {- Box::new(wasm_memorytype_t::new(MemoryType::new(- limits.min,- limits.max(),- )))+pub extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Option<Box<wasm_memorytype_t>> {+ let ty = MemoryType::new(limits.min, limits.max()).ok()?;+ Some(Box::new(wasm_memorytype_t::new(ty)))}#[unsafe(no_mangle)]diff --git a/crates/c-api/src/types/table.rs b/crates/c-api/src/types/table.rsindex 48173f86ee..55b057a94f 100644--- a/crates/c-api/src/types/table.rs+++ b/crates/c-api/src/types/table.rs@@ -55,11 +55,8 @@ pub extern "C" fn wasm_tabletype_new(limits: &wasm_limits_t,) -> Option<Box<wasm_tabletype_t>> {let ty = (*ty).as_ref()?.clone();- Some(Box::new(wasm_tabletype_t::new(TableType::new(- ty,- limits.min,- limits.max(),- ))))+ let ty = TableType::new(ty, limits.min, limits.max()).ok()?;+ Some(Box::new(wasm_tabletype_t::new(ty)))}#[unsafe(no_mangle)]diff --git a/crates/fuzzing/src/oracles/api.rs b/crates/fuzzing/src/oracles/api.rsindex 2fcacd0b96..167e09a51c 100644--- a/crates/fuzzing/src/oracles/api.rs+++ b/crates/fuzzing/src/oracles/api.rs@@ -269,7 +269,7 @@ pub fn make_api_calls(api: ApiCalls) {ApiCall::TableTypeNew { id, nullable } => {log::trace!("creating table type {id}");let element = RefType::new(nullable, HeapType::Func);- let old = table_types.insert(id, TableType::new(element, 0, None));+ let old = table_types.insert(id, TableType::new(element, 0, None).unwrap());assert!(old.is_none());}@@ -404,7 +404,7 @@ pub fn make_api_calls(api: ApiCalls) {maximum,} => {log::trace!("creating memory type {id}");- let old = memory_types.insert(id, MemoryType::new(minimum, maximum));+ let old = memory_types.insert(id, MemoryType::new(minimum, maximum).unwrap());assert!(old.is_none());}diff --git a/crates/fuzzing/src/oracles/dummy.rs b/crates/fuzzing/src/oracles/dummy.rsindex 11918e4572..301834dbf4 100644--- a/crates/fuzzing/src/oracles/dummy.rs+++ b/crates/fuzzing/src/oracles/dummy.rs@@ -35,7 +35,7 @@ mod tests {#[test]fn dummy_table_import() {let mut store = store();- let table_type = TableType::new(RefType::EXTERNREF, 10, None);+ let table_type = TableType::new(RefType::EXTERNREF, 10, None).unwrap();let table = table_type.default_value(&mut store).unwrap();assert_eq!(table.size(&store), 10);for i in 0..10 {@@ -55,7 +55,7 @@ mod tests {#[test]fn dummy_memory_import() {let mut store = store();- let memory_type = MemoryType::new(1, None);+ let memory_type = MemoryType::new(1, None).unwrap();let memory = memory_type.default_value(&mut store).unwrap()diff --git a/crates/fuzzing/tests/oom/memory.rs b/crates/fuzzing/tests/oom/memory.rsindex a2361a7130..8f986cb96d 100644--- a/crates/fuzzing/tests/oom/memory.rs+++ b/crates/fuzzing/tests/oom/memory.rs@@ -16,7 +16,7 @@ fn memory_new() -> Result<()> {.allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let _memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let _memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;Ok(())})}@@ -32,7 +32,7 @@ async fn memory_new_async() -> Result<()> {.allow_alloc_after_oom(true).test_async(|| async {let mut store = Store::try_new(&engine, ())?;- let _memory = Memory::new_async(&mut store, MemoryType::new(1, None)).await?;+ let _memory = Memory::new_async(&mut store, MemoryType::new(1, None)?).await?;Ok(())}).await@@ -47,7 +47,7 @@ fn memory_grow() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;let _old_size = memory.grow(&mut store, 1)?;Ok(())})@@ -64,7 +64,7 @@ async fn memory_grow_async() -> Result<()> {.allow_alloc_after_oom(true).test_async(|| async {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new_async(&mut store, MemoryType::new(1, None)).await?;+ let memory = Memory::new_async(&mut store, MemoryType::new(1, None)?).await?;let _old_size = memory.grow_async(&mut store, 1).await?;Ok(())})@@ -80,7 +80,7 @@ fn memory_ty() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;let _ty = memory.ty(&store);Ok(())})@@ -95,7 +95,7 @@ fn memory_size() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;assert_eq!(memory.size(&store), 1);Ok(())})@@ -110,7 +110,7 @@ fn memory_data_size() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;assert_eq!(memory.data_size(&store), 65536);Ok(())})@@ -125,7 +125,7 @@ fn memory_read_write() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;memory.write(&mut store, 0, &[1, 2, 3, 4])?;let mut buf = [0u8; 4];memory.read(&store, 0, &mut buf)?;@@ -143,7 +143,7 @@ fn memory_data() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;let data = memory.data(&store);assert_eq!(data.len(), 65536);Ok(())@@ -159,7 +159,7 @@ fn memory_data_mut() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;let data = memory.data_mut(&mut store);data[0] = 42;assert_eq!(data[0], 42);diff --git a/crates/fuzzing/tests/oom/table.rs b/crates/fuzzing/tests/oom/table.rsindex b797dfe6e3..abd2bcfc04 100644--- a/crates/fuzzing/tests/oom/table.rs+++ b/crates/fuzzing/tests/oom/table.rs@@ -16,7 +16,7 @@ fn table_new() -> Result<()> {.allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let _table = wasmtime::Table::new(&mut store, ty, Ref::Func(None))?;Ok(())})@@ -33,7 +33,7 @@ async fn table_new_async() -> Result<()> {.allow_alloc_after_oom(true).test_async(|| async {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let _table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;Ok(())})@@ -49,7 +49,7 @@ fn table_grow() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;let _old_size = table.grow(&mut store, 4, Ref::Func(None))?;Ok(())@@ -67,7 +67,7 @@ async fn table_grow_async() -> Result<()> {.allow_alloc_after_oom(true).test_async(|| async {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;let _old_size = table.grow_async(&mut store, 4, Ref::Func(None)).await?;Ok(())@@ -84,7 +84,7 @@ fn table_set() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;table.set(&mut store, 0, Ref::Func(None))?;Ok(())@@ -100,7 +100,7 @@ fn table_copy() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 4, None);+ let ty = TableType::new(RefType::FUNCREF, 4, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;Table::copy(&mut store, &table, 0, &table, 2, 2)?;Ok(())@@ -116,7 +116,7 @@ fn table_fill() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 4, None);+ let ty = TableType::new(RefType::FUNCREF, 4, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;table.fill(&mut store, 0, Ref::Func(None), 4)?;Ok(())@@ -132,7 +132,7 @@ fn table_get() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;let val = table.get(&mut store, 0);assert!(val.is_some());@@ -149,7 +149,7 @@ fn table_ty() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;let _ty = table.ty(&store);Ok(())@@ -165,7 +165,7 @@ fn table_size() -> Result<()> {OomTest::new().allow_alloc_after_oom(true).test(|| {let mut store = Store::try_new(&engine, ())?;- let ty = TableType::new(RefType::FUNCREF, 2, None);+ let ty = TableType::new(RefType::FUNCREF, 2, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;assert_eq!(table.size(&store), 2);Ok(())diff --git a/crates/fuzzing/tests/oom/types.rs b/crates/fuzzing/tests/oom/types.rsindex ff5a156bbc..47c8d00b35 100644--- a/crates/fuzzing/tests/oom/types.rs+++ b/crates/fuzzing/tests/oom/types.rs@@ -22,7 +22,7 @@ fn func_type_params_results() -> Result<()> {#[test]fn table_type_accessors() -> Result<()> {OomTest::new().test(|| {- let ty = TableType::new(RefType::FUNCREF, 1, Some(10));+ let ty = TableType::new(RefType::FUNCREF, 1, Some(10))?;assert_eq!(ty.minimum(), 1);assert_eq!(ty.maximum(), Some(10));Ok(())@@ -32,7 +32,7 @@ fn table_type_accessors() -> Result<()> {#[test]fn memory_type_accessors() -> Result<()> {OomTest::new().test(|| {- let ty = MemoryType::new(1, Some(10));+ let ty = MemoryType::new(1, Some(10))?;assert_eq!(ty.minimum(), 1);assert_eq!(ty.maximum(), Some(10));assert!(!ty.is_64());diff --git a/crates/wasmtime/src/runtime/externals/table.rs b/crates/wasmtime/src/runtime/externals/table.rsindex b1c994d7ad..752570d354 100644--- a/crates/wasmtime/src/runtime/externals/table.rs+++ b/crates/wasmtime/src/runtime/externals/table.rs@@ -77,7 +77,7 @@ impl Table {/// let engine = Engine::default();/// let mut store = Store::new(&engine, ());///- /// let ty = TableType::new(RefType::FUNCREF, 2, None);+ /// let ty = TableType::new(RefType::FUNCREF, 2, None)?;/// let table = Table::new(&mut store, ty, Ref::Func(None))?;////// let module = Module::new(diff --git a/crates/wasmtime/src/runtime/memory.rs b/crates/wasmtime/src/runtime/memory.rsindex 3955d541c7..8942faebfa 100644--- a/crates/wasmtime/src/runtime/memory.rs+++ b/crates/wasmtime/src/runtime/memory.rs@@ -251,7 +251,7 @@ impl Memory {/// let engine = Engine::default();/// let mut store = Store::new(&engine, ());///- /// let memory_ty = MemoryType::new(1, None);+ /// let memory_ty = MemoryType::new(1, None)?;/// let memory = Memory::new(&mut store, memory_ty)?;////// let module = Module::new(&engine, "(module (memory (import \"\" \"\") 1))")?;@@ -848,7 +848,7 @@ pub unsafe trait MemoryCreator: Send + Sync {/// let engine = Engine::new(&config)?;/// let mut store = Store::new(&engine, ());///-/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2))?;+/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2)?)?;/// let module = Module::new(&engine, r#"(module (memory (import "" "") 1 2 shared))"#)?;/// let instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;/// // ...@@ -1113,7 +1113,7 @@ mod tests {let mut cfg = Config::new();cfg.memory_reservation(0).memory_guard_size(0);let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None).unwrap();let mem = Memory::new(&mut store, ty).unwrap();let store = store.as_context();let tunables = store.engine().tunables();diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rsindex 62f51b8224..294c3281a1 100644--- a/crates/wasmtime/src/runtime/store.rs+++ b/crates/wasmtime/src/runtime/store.rs@@ -900,6 +900,7 @@ impl<T> Store<T> {/// limits: StoreLimits,/// }///+ /// # fn main() -> Result<()> {/// let engine = Engine::default();/// let my_state = MyApplicationState {/// my_state: 42,@@ -912,18 +913,20 @@ impl<T> Store<T> {/// store.limiter(|state| &mut state.limits);////// // Creation of smaller memories is allowed- /// Memory::new(&mut store, MemoryType::new(1, None)).unwrap();+ /// Memory::new(&mut store, MemoryType::new(1, None)?)?;////// // Creation of a larger memory, however, will exceed the 1MB limit we've/// // configured- /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)).is_err());+ /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)?).is_err());////// // The number of instances in this store is limited to 2, so the third/// // instance here should fail.- /// let module = Module::new(&engine, "(module)").unwrap();- /// assert!(Instance::new(&mut store, &module, &[]).is_ok());- /// assert!(Instance::new(&mut store, &module, &[]).is_ok());+ /// let module = Module::new(&engine, "(module)")?;+ /// Instance::new(&mut store, &module, &[])?;+ /// Instance::new(&mut store, &module, &[])?;/// assert!(Instance::new(&mut store, &module, &[]).is_err());+ /// # Ok(())+ /// # }/// ```////// [`ResourceLimiter`]: crate::ResourceLimiterdiff --git a/crates/wasmtime/src/runtime/types.rs b/crates/wasmtime/src/runtime/types.rsindex fc3e313d48..2d4023269e 100644--- a/crates/wasmtime/src/runtime/types.rs+++ b/crates/wasmtime/src/runtime/types.rs@@ -3174,7 +3174,16 @@ pub struct TableType {impl TableType {/// Creates a new table descriptor which will contain the specified/// `element` and have the `limits` applied to its length.- pub fn new(element: RefType, min: u32, max: Option<u32>) -> TableType {+ ///+ /// # Errors+ ///+ /// Returns an error if the minimum is greater than the maximum.+ pub fn new(element: RefType, min: u32, max: Option<u32>) -> Result<TableType> {+ if let Some(max) = max+ && max < min+ {+ bail!("table's maximum size cannot be smaller than its minimum size");+ }let ref_type = element.to_wasm_type();debug_assert!(@@ -3187,21 +3196,30 @@ impl TableType {max: max.map(|x| u64::from(x)),};- TableType {+ Ok(TableType {element,ty: Table {idx_type: IndexType::I32,limits,ref_type,},- }+ })}/// Crates a new descriptor for a 64-bit table.////// Note that 64-bit tables are part of the memory64 proposal for/// WebAssembly which is not standardized yet.- pub fn new64(element: RefType, min: u64, max: Option<u64>) -> TableType {+ ///+ /// # Errors+ ///+ /// Returns an error if the minimum is greater than the maximum.+ pub fn new64(element: RefType, min: u64, max: Option<u64>) -> Result<TableType> {+ if let Some(max) = max+ && max < min+ {+ bail!("table's maximum size cannot be smaller than its minimum size");+ }let ref_type = element.to_wasm_type();debug_assert!(@@ -3209,14 +3227,14 @@ impl TableType {"should be canonicalized for runtime usage: {ref_type:?}");- TableType {+ Ok(TableType {element,ty: Table {ref_type,idx_type: IndexType::I64,limits: Limits { min, max },},- }+ })}/// Returns whether or not this table is a 64-bit table.@@ -3475,17 +3493,16 @@ impl MemoryType {/// [`MemoryTypeBuilder`][crate::MemoryTypeBuilder] if you want a/// non-default page size.///- /// # Panics+ /// # Errors///- /// Panics if the minimum is greater than the maximum or if the minimum or- /// maximum number of pages can result in a byte size that is not- /// addressable with a 32-bit integer.- pub fn new(minimum: u32, maximum: Option<u32>) -> MemoryType {+ /// Returns an error if the minimum is greater than the maximum or if the+ /// minimum or maximum number of pages can result in a byte size that is+ /// not addressable with a 32-bit integer.+ pub fn new(minimum: u32, maximum: Option<u32>) -> Result<MemoryType> {MemoryTypeBuilder::default().min(minimum.into()).max(maximum.map(Into::into)).build()- .unwrap()}/// Creates a new descriptor for a 64-bit WebAssembly memory given the@@ -3500,18 +3517,17 @@ impl MemoryType {/// proposal](https://github.com/WebAssembly/memory64) for WebAssembly which/// is not fully standardized yet.///- /// # Panics+ /// # Errors///- /// Panics if the minimum is greater than the maximum or if the minimum or- /// maximum number of pages can result in a byte size that is not- /// addressable with a 64-bit integer.- pub fn new64(minimum: u64, maximum: Option<u64>) -> MemoryType {+ /// Returns an error if the minimum is greater than the maximum or if the+ /// minimum or maximum number of pages can result in a byte size that is+ /// not addressable with a 64-bit integer.+ pub fn new64(minimum: u64, maximum: Option<u64>) -> Result<MemoryType> {MemoryTypeBuilder::default().memory64(true).min(minimum).max(maximum).build()- .unwrap()}/// Creates a new descriptor for shared WebAssembly memory given the@@ -3526,18 +3542,17 @@ impl MemoryType {/// proposal](https://github.com/WebAssembly/threads) for WebAssembly which/// is not fully standardized yet.///- /// # Panics+ /// # Errors///- /// Panics if the minimum is greater than the maximum or if the minimum or- /// maximum number of pages can result in a byte size that is not- /// addressable with a 32-bit integer.- pub fn shared(minimum: u32, maximum: u32) -> MemoryType {+ /// Returns an error if the minimum is greater than the maximum or if the+ /// minimum or maximum number of pages can result in a byte size that is+ /// not addressable with a 32-bit integer.+ pub fn shared(minimum: u32, maximum: u32) -> Result<MemoryType> {MemoryTypeBuilder::default().shared(true).min(minimum.into()).max(Some(maximum.into())).build()- .unwrap()}/// Creates a new [`MemoryTypeBuilder`] to configure all the various knobsdiff --git a/crates/wast/src/spectest.rs b/crates/wast/src/spectest.rsindex b99421d7e0..4f5dd541e9 100644--- a/crates/wast/src/spectest.rs+++ b/crates/wast/src/spectest.rs@@ -66,20 +66,20 @@ pub fn link_spectest<T>(let g = Global::new(&mut *store, ty, Val::F64(0x4084_d4cc_cccc_cccd))?;linker.define(&mut *store, "spectest", "global_f64", g)?;- let ty = TableType::new(RefType::FUNCREF, 10, Some(20));+ let ty = TableType::new(RefType::FUNCREF, 10, Some(20))?;let table = Table::new(&mut *store, ty, Ref::Func(None))?;linker.define(&mut *store, "spectest", "table", table)?;- let ty = TableType::new64(RefType::FUNCREF, 10, Some(20));+ let ty = TableType::new64(RefType::FUNCREF, 10, Some(20))?;let table = Table::new(&mut *store, ty, Ref::Func(None))?;linker.define(&mut *store, "spectest", "table64", table)?;- let ty = MemoryType::new(1, Some(2));+ let ty = MemoryType::new(1, Some(2))?;let memory = Memory::new(&mut *store, ty)?;linker.define(&mut *store, "spectest", "memory", memory)?;if config.use_shared_memory {- let ty = MemoryType::shared(1, 1);+ let ty = MemoryType::shared(1, 1)?;let memory = SharedMemory::new(store.engine(), ty)?;linker.define(&mut *store, "spectest", "shared_memory", memory)?;}diff --git a/examples/memory.rs b/examples/memory.rsindex ef187c724f..3bc3adfba5 100644--- a/examples/memory.rs+++ b/examples/memory.rs@@ -63,7 +63,7 @@ fn main() -> Result<()> {assert!(memory.grow(&mut store, 0).is_ok());println!("Creating stand-alone memory...");- let memorytype = MemoryType::new(5, Some(5));+ let memorytype = MemoryType::new(5, Some(5))?;let memory2 = Memory::new(&mut store, memorytype)?;assert_eq!(memory2.size(&store), 5);assert!(memory2.grow(&mut store, 1).is_err());diff --git a/src/commands/serve.rs b/src/commands/serve.rsindex deb3272ac0..d36cc9fe6d 100644--- a/src/commands/serve.rs+++ b/src/commands/serve.rs@@ -1636,7 +1636,7 @@ fn use_pooling_allocator_by_default() -> Result<Option<bool>> {let mut store = Store::new(&engine, ());// NB: the maximum size is in wasm pages to take out the 16-bits of wasm// page size here from the maximum size.- let ty = MemoryType::new64(0, Some(1 << (BITS_TO_TEST - 16)));+ let ty = MemoryType::new64(0, Some(1 << (BITS_TO_TEST - 16)))?;if Memory::new(&mut store, ty).is_ok() {Ok(Some(true))} else {diff --git a/tests/all/coredump.rs b/tests/all/coredump.rsindex 605118d7f9..8001fba646 100644--- a/tests/all/coredump.rs+++ b/tests/all/coredump.rs@@ -136,7 +136,7 @@ fn coredump_has_host_globals_and_memory() -> Result<()> {let mut store = Store::<()>::new(&engine, ());let mut linker = Linker::new(&engine);- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;linker.define(&mut store, "memory", "memory", memory)?;let global = Global::new(@@ -210,7 +210,7 @@ fn multiple_globals_memories_and_instances() -> Result<()> {let mut store = Store::<()>::new(&engine, ());let mut linker = Linker::new(&engine);- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;linker.define(&mut store, "host", "memory", memory)?;let global = Global::new(diff --git a/tests/all/cross_engine.rs b/tests/all/cross_engine.rsindex f216865fb8..4b90b345fc 100644--- a/tests/all/cross_engine.rs+++ b/tests/all/cross_engine.rs@@ -320,7 +320,7 @@ fn table_new_rejects_foreign_type() -> Result<()> {)],)?;let foreign_heap_ty = HeapType::ConcreteStruct(foreign_struct);- let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None);+ let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None)?;Table::new(&mut store, foreign_ty, Ref::null(&foreign_heap_ty)).unwrap_err()@@ -346,7 +346,7 @@ async fn table_new_async_rejects_foreign_type() -> Result<()> {)],)?;let foreign_heap_ty = HeapType::ConcreteStruct(foreign_struct);- let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None);+ let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None)?;Table::new_async(&mut store, foreign_ty, Ref::null(&foreign_heap_ty)).awaitdiff --git a/tests/all/externals.rs b/tests/all/externals.rsindex 31cfc243b6..f41bb76c8f 100644--- a/tests/all/externals.rs+++ b/tests/all/externals.rs@@ -22,32 +22,32 @@ fn bad_tables() {let mut store = Store::<()>::default();// mismatched initializer- let ty = TableType::new(RefType::FUNCREF, 0, Some(1));+ let ty = TableType::new(RefType::FUNCREF, 0, Some(1)).unwrap();assert!(Table::new(&mut store, ty.clone(), Ref::Extern(None)).is_err());// get out of bounds- let ty = TableType::new(RefType::FUNCREF, 0, Some(1));+ let ty = TableType::new(RefType::FUNCREF, 0, Some(1)).unwrap();let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();assert!(t.get(&mut store, 0).is_none());assert!(t.get(&mut store, u64::from(u32::MAX)).is_none());assert!(t.get(&mut store, u64::MAX).is_none());// set out of bounds or wrong type- let ty = TableType::new(RefType::FUNCREF, 1, Some(1));+ let ty = TableType::new(RefType::FUNCREF, 1, Some(1)).unwrap();let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();assert!(t.set(&mut store, 0, Ref::Extern(None)).is_err());assert!(t.set(&mut store, 0, Ref::Func(None)).is_ok());assert!(t.set(&mut store, 1, Ref::Func(None)).is_err());// grow beyond max- let ty = TableType::new(RefType::FUNCREF, 1, Some(1));+ let ty = TableType::new(RefType::FUNCREF, 1, Some(1)).unwrap();let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();assert!(t.grow(&mut store, 0, Ref::Func(None)).is_ok());assert!(t.grow(&mut store, 1, Ref::Func(None)).is_err());assert_eq!(t.size(&store), 1);// grow wrong type- let ty = TableType::new(RefType::FUNCREF, 1, Some(2));+ let ty = TableType::new(RefType::FUNCREF, 1, Some(2)).unwrap();let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();assert!(t.grow(&mut store, 1, Ref::Extern(None)).is_err());assert_eq!(t.size(&store), 1);@@ -67,9 +67,9 @@ fn cross_store() -> wasmtime::Result<()> {let func = Func::wrap(&mut store2, || {});let ty = GlobalType::new(ValType::I32, Mutability::Const);let global = Global::new(&mut store2, ty, Val::I32(0))?;- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None)?;let memory = Memory::new(&mut store2, ty)?;- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store2, ty, Ref::Func(None))?;let need_func = Module::new(&engine, r#"(module (import "" "" (func)))"#)?;@@ -99,7 +99,7 @@ fn cross_store() -> wasmtime::Result<()> {eprintln!("============ Cross-store tables ==============");- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;assert!(Table::new(&mut store2, ty.clone(), store1ref.clone()).is_err());let t1 = Table::new(&mut store2, ty.clone(), store2ref.clone())?;assert!(t1.set(&mut store2, 0, store1ref.clone()).is_err());@@ -248,7 +248,7 @@ fn create_get_set_funcref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::FUNCREF, 10, None);+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;let init = Ref::Func(Some(Func::wrap(&mut store, || {})));let table = Table::new(&mut store, table_ty, init)?;@@ -266,7 +266,7 @@ fn fill_funcref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::FUNCREF, 10, None);+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;let table = Table::new(&mut store, table_ty, Ref::Func(None))?;for i in 0..10 {@@ -293,7 +293,7 @@ fn grow_funcref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::FUNCREF, 10, None);+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;let table = Table::new(&mut store, table_ty, Ref::Func(None))?;assert_eq!(table.size(&store), 10);@@ -310,7 +310,7 @@ fn create_get_set_externref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;let init = ExternRef::new(&mut store, 42_usize)?;let table = Table::new(&mut store, table_ty, init.into())?;@@ -339,7 +339,7 @@ fn fill_externref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;for i in 0..10 {@@ -377,7 +377,7 @@ fn grow_externref_tables_via_api() -> wasmtime::Result<()> {let engine = Engine::new(&cfg)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;assert_eq!(table.size(&store), 10);@@ -391,7 +391,7 @@ fn grow_externref_tables_via_api() -> wasmtime::Result<()> {fn read_write_memory_via_api() {let cfg = Config::new();let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None).unwrap();let mem = Memory::new(&mut store, ty).unwrap();mem.grow(&mut store, 1).unwrap();@@ -607,7 +607,7 @@ fn new_table_func_subtyping() {for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {match Table::new(&mut store,- TableType::new(RefType::new(true, table_ty.clone().into()), 0, None),+ TableType::new(RefType::new(true, table_ty.clone().into()), 0, None).unwrap(),val.into(),) {Ok(_) if expected => {}@@ -637,7 +637,7 @@ fn table_set_func_subtyping() {] {let table = Table::new(&mut store,- TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),+ TableType::new(RefType::new(true, table_ty.clone().into()), 3, None).unwrap(),Ref::Func(None),).unwrap();@@ -680,7 +680,7 @@ fn table_grow_func_subtyping() {] {let table = Table::new(&mut store,- TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),+ TableType::new(RefType::new(true, table_ty.clone().into()), 3, None).unwrap(),Ref::Func(None),).unwrap();@@ -725,7 +725,7 @@ fn table_fill_func_subtyping() {for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {let table = Table::new(&mut store,- TableType::new(RefType::new(true, table_ty.clone().into()), 10, None),+ TableType::new(RefType::new(true, table_ty.clone().into()), 10, None).unwrap(),Ref::Func(None),).unwrap();@@ -766,7 +766,7 @@ fn table_copy_func_subtyping() {] {let dest_table = Table::new(&mut store,- TableType::new(RefType::new(true, dst_ty.clone().into()), 10, None),+ TableType::new(RefType::new(true, dst_ty.clone().into()), 10, None).unwrap(),Ref::Func(None),).unwrap();@@ -780,7 +780,7 @@ fn table_copy_func_subtyping() {let src_table = Table::new(&mut store,- TableType::new(RefType::new(true, src_ty.into()), 10, None),+ TableType::new(RefType::new(true, src_ty.into()), 10, None).unwrap(),val.into(),).unwrap();diff --git a/tests/all/func.rs b/tests/all/func.rsindex 4c94c67e64..3a1f42f750 100644--- a/tests/all/func.rs+++ b/tests/all/func.rs@@ -287,7 +287,7 @@ fn call_indirect_native_from_wasm_import_table(config: &mut Config) -> Result<()let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });let table = Table::new(&mut store,- TableType::new(RefType::FUNCREF, 1, Some(1)),+ TableType::new(RefType::FUNCREF, 1, Some(1))?,Ref::Func(Some(func)),)?;let instance = Instance::new(&mut store, &module, &[table.into()])?;diff --git a/tests/all/gc.rs b/tests/all/gc.rsindex 34e6c7eec1..3b27a5d094 100644--- a/tests/all/gc.rs+++ b/tests/all/gc.rs@@ -343,7 +343,7 @@ fn table_drops_externref() -> Result<()> {let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;Table::new(&mut store,- TableType::new(RefType::EXTERNREF, 1, None),+ TableType::new(RefType::EXTERNREF, 1, None)?,externref.into(),)?;drop(store);@@ -845,7 +845,7 @@ fn table_fill_doesnt_leak() -> Result<()> {let x = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;let table = Table::new(&mut scope,- TableType::new(RefType::EXTERNREF, 10, Some(10)),+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,x.into(),)?;table.fill(&mut scope, 0, Ref::Extern(None), 10)?;@@ -868,7 +868,7 @@ fn table_copy_doesnt_leak() -> Result<()> {let mut scope = RootScope::new(&mut store);let table = Table::new(&mut scope,- TableType::new(RefType::EXTERNREF, 10, Some(10)),+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,Ref::Extern(None),)?;@@ -895,7 +895,7 @@ fn table_set_doesnt_leak() -> Result<()> {let mut scope = RootScope::new(&mut store);let table = Table::new(&mut scope,- TableType::new(RefType::EXTERNREF, 10, Some(10)),+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,Ref::Extern(None),)?;@@ -922,7 +922,7 @@ fn table_grow_doesnt_leak() -> Result<()> {let mut scope = RootScope::new(&mut store);let table = Table::new(&mut scope,- TableType::new(RefType::EXTERNREF, 10, Some(10)),+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,Ref::Extern(None),)?;@@ -3452,7 +3452,7 @@ fn miri_gc_smoke_test() -> Result<()> {&engine,[FieldType::new(Mutability::Const, StorageType::I8)],)?;- let table_ty = TableType::new(RefType::ANYREF, 1, None);+ let table_ty = TableType::new(RefType::ANYREF, 1, None)?;let global_ty = GlobalType::new(RefType::ANYREF.into(), Mutability::Var);let exn_ty = ExnType::new(&engine, [ValType::I32])?;let func_ty = FuncType::new(&engine, Some(ValType::I32), None);diff --git a/tests/all/limits.rs b/tests/all/limits.rsindex 1e75a38d12..bff7d1b748 100644--- a/tests/all/limits.rs+++ b/tests/all/limits.rs@@ -30,7 +30,7 @@ fn test_limits() -> Result<()> {// Test instance exports and host objects hitting the limitfor memory in IntoIterator::into_iter([instance.get_memory(&mut store, "m").unwrap(),- Memory::new(&mut store, MemoryType::new(0, None))?,+ Memory::new(&mut store, MemoryType::new(0, None)?)?,]) {memory.grow(&mut store, 3)?;memory.grow(&mut store, 5)?;@@ -50,7 +50,7 @@ fn test_limits() -> Result<()> {instance.get_table(&mut store, "t").unwrap(),Table::new(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),)?,]) {@@ -138,7 +138,7 @@ async fn test_limits_async() -> Result<()> {// Test instance exports and host objects hitting the limitfor memory in IntoIterator::into_iter([instance.get_memory(&mut store, "m").unwrap(),- Memory::new_async(&mut store, MemoryType::new(0, None)).await?,+ Memory::new_async(&mut store, MemoryType::new(0, None)?).await?,]) {memory.grow_async(&mut store, 3).await?;memory.grow_async(&mut store, 5).await?;@@ -159,7 +159,7 @@ async fn test_limits_async() -> Result<()> {instance.get_table(&mut store, "t").unwrap(),Table::new_async(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),).await?,@@ -202,7 +202,7 @@ fn test_limits_memory_only() -> Result<()> {// Test instance exports and host objects hitting the limitfor memory in IntoIterator::into_iter([instance.get_memory(&mut store, "m").unwrap(),- Memory::new(&mut store, MemoryType::new(0, None))?,+ Memory::new(&mut store, MemoryType::new(0, None)?)?,]) {memory.grow(&mut store, 3)?;memory.grow(&mut store, 5)?;@@ -222,7 +222,7 @@ fn test_limits_memory_only() -> Result<()> {instance.get_table(&mut store, "t").unwrap(),Table::new(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),)?,]) {@@ -256,7 +256,7 @@ fn test_initial_memory_limits_exceeded() -> Result<()> {),}- match Memory::new(&mut store, MemoryType::new(25, None)) {+ match Memory::new(&mut store, MemoryType::new(25, None)?) {Ok(_) => unreachable!(),Err(e) => assert_eq!(e.to_string(),@@ -283,7 +283,7 @@ fn test_limits_table_only() -> Result<()> {// Test instance exports and host objects *not* hitting the limitfor memory in IntoIterator::into_iter([instance.get_memory(&mut store, "m").unwrap(),- Memory::new(&mut store, MemoryType::new(0, None))?,+ Memory::new(&mut store, MemoryType::new(0, None)?)?,]) {memory.grow(&mut store, 3)?;memory.grow(&mut store, 5)?;@@ -296,7 +296,7 @@ fn test_limits_table_only() -> Result<()> {instance.get_table(&mut store, "t").unwrap(),Table::new(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),)?,]) {@@ -334,7 +334,7 @@ fn test_initial_table_limits_exceeded() -> Result<()> {match Table::new(&mut store,- TableType::new(RefType::FUNCREF, 99, None),+ TableType::new(RefType::FUNCREF, 99, None)?,Ref::Func(None),) {Ok(_) => unreachable!(),@@ -1135,7 +1135,7 @@ fn growth_trap() -> Result<()> {// Test instance exports and host objects hitting the limitfor memory in [instance.get_memory(&mut store, "m").unwrap(),- Memory::new(&mut store, MemoryType::new(0, None))?,+ Memory::new(&mut store, MemoryType::new(0, None)?)?,] {memory.grow(&mut store, 1)?;assert!(memory.grow(&mut store, 1).is_err());@@ -1146,7 +1146,7 @@ fn growth_trap() -> Result<()> {instance.get_table(&mut store, "t").unwrap(),Table::new(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),)?,] {diff --git a/tests/all/linker.rs b/tests/all/linker.rsindex de6614ea60..b16af64c95 100644--- a/tests/all/linker.rs+++ b/tests/all/linker.rs@@ -73,20 +73,20 @@ fn link_twice_bad() -> Result<()> {assert!(linker.define(&mut store, "g", "3", global).is_err());// memories- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None)?;let memory = Memory::new(&mut store, ty)?;linker.define(&mut store, "m", "", memory)?;assert!(linker.define(&mut store, "m", "", memory).is_err());- let ty = MemoryType::new(2, None);+ let ty = MemoryType::new(2, None)?;let memory = Memory::new(&mut store, ty)?;assert!(linker.define(&mut store, "m", "", memory).is_err());// tables- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;linker.define(&mut store, "t", "", table)?;assert!(linker.define(&mut store, "t", "", table).is_err());- let ty = TableType::new(RefType::FUNCREF, 2, None);+ let ty = TableType::new(RefType::FUNCREF, 2, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;assert!(linker.define(&mut store, "t", "", table).is_err());Ok(())@@ -754,7 +754,7 @@ fn linker_defines_table_subtype_err() -> Result<()> {let mut linker = Linker::new(&engine);let t = Table::new(&mut store,- TableType::new(RefType::FUNCREF, 0, None),+ TableType::new(RefType::FUNCREF, 0, None)?,Ref::Func(None),)?;linker.define(&store, "env", "t", t)?;@@ -765,7 +765,7 @@ fn linker_defines_table_subtype_err() -> Result<()> {let mut linker = Linker::new(&engine);let t = Table::new(&mut store,- TableType::new(RefType::NULLFUNCREF, 0, None),+ TableType::new(RefType::NULLFUNCREF, 0, None)?,Ref::Func(None),)?;linker.define(&store, "env", "t", t)?;diff --git a/tests/all/memory.rs b/tests/all/memory.rsindex 89ed1ec0b8..f9f4d57b8a 100644--- a/tests/all/memory.rs+++ b/tests/all/memory.rs@@ -121,7 +121,7 @@ fn offsets_static_dynamic_oh_my(config: &mut Config) -> Result<()> {for (min, max) in [(1, Some(2)), (1, None)].iter() {let mut store = Store::new(&engine, ());- let mem = Memory::new(&mut store, MemoryType::new(*min, *max)).unwrap();+ let mem = Memory::new(&mut store, MemoryType::new(*min, *max)?).unwrap();let instance = Instance::new(&mut store, &module, &[mem.into()]).unwrap();let funcs = find_funcs(&mut store, &instance);@@ -153,8 +153,8 @@ fn guards_present() -> Result<()> {config.guard_before_linear_memory(true);let engine = Engine::new(&config)?;let mut store = Store::new(&engine, ());- let static_mem = Memory::new(&mut store, MemoryType::new(1, Some(2)))?;- let dynamic_mem = Memory::new(&mut store, MemoryType::new(1, None))?;+ let static_mem = Memory::new(&mut store, MemoryType::new(1, Some(2))?)?;+ let dynamic_mem = Memory::new(&mut store, MemoryType::new(1, None)?)?;let assert_guards = |store: &Store<()>| unsafe {// guards before@@ -369,7 +369,7 @@ fn massive_64_bit_still_limited() -> Result<()> {let mut store = Store::new(&engine, MyLimiter { hit: false });store.limiter(|x| x);- let ty = MemoryType::new64(1 << 46, None);+ let ty = MemoryType::new64(1 << 46, None)?;assert!(Memory::new(&mut store, ty).is_err());assert!(store.data().hit);@@ -445,7 +445,7 @@ fn static_forced_max() -> Result<()> {let engine = Engine::new(&config)?;let mut store = Store::new(&engine, ());- let mem = Memory::new(&mut store, MemoryType::new(0, None))?;+ let mem = Memory::new(&mut store, MemoryType::new(0, None)?)?;mem.grow(&mut store, 5).unwrap();assert!(mem.grow(&mut store, 1).is_err());Ok(())@@ -505,7 +505,7 @@ fn dynamic_extra_growth_unchanged_pointer(config: &mut Config) -> Result<()> {Ok(())}- let mem = Memory::new(&mut store, MemoryType::new(10, None))?;+ let mem = Memory::new(&mut store, MemoryType::new(10, None)?)?;assert_behaves_well(&mut store, &mem)?;let module = Module::new(&engine, r#"(module (memory (export "mem") 10))"#)?;@@ -595,10 +595,10 @@ fn shared_memory_basics() -> Result<()> {let mut config = Config::new();config.shared_memory(true);let engine = Engine::new(&config)?;- assert!(SharedMemory::new(&engine, MemoryType::new(1, None)).is_err());- assert!(SharedMemory::new(&engine, MemoryType::new(1, Some(1))).is_err());- assert!(SharedMemory::new(&engine, MemoryType::new64(1, None)).is_err());- assert!(SharedMemory::new(&engine, MemoryType::new64(1, Some(1))).is_err());+ assert!(SharedMemory::new(&engine, MemoryType::new(1, None)?).is_err());+ assert!(SharedMemory::new(&engine, MemoryType::new(1, Some(1))?).is_err());+ assert!(SharedMemory::new(&engine, MemoryType::new64(1, None)?).is_err());+ assert!(SharedMemory::new(&engine, MemoryType::new64(1, Some(1))?).is_err());assert!(MemoryTypeBuilder::default().shared(true)@@ -608,7 +608,7 @@ fn shared_memory_basics() -> Result<()> {.is_err());- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;assert!(memory.ty().is_shared());assert_eq!(memory.ty().minimum(), 1);assert_eq!(memory.ty().maximum(), Some(1));@@ -670,7 +670,7 @@ fn shared_memory_wait_notify() -> Result<()> {let mut config = Config::new();config.shared_memory(true);let engine = Engine::new(&config)?;- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;let data = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().cast_mut().cast()) };let locked = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().add(4).cast_mut().cast()) };@@ -789,7 +789,7 @@ fn non_page_aligned_static_memory() -> Result<()> {config.memory_reservation(100_000);config.memory_may_move(false);let engine = Engine::new(&config)?;- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None)?;Memory::new(&mut Store::new(&engine, ()), ty)?;Ok(())}@@ -857,7 +857,7 @@ fn configure_zero(config: &mut Config) -> Result<()> {let engine = Engine::new(&config)?;let mut store = Store::new(&engine, ());- let ty = MemoryType::new(0, None);+ let ty = MemoryType::new(0, None)?;let memory = Memory::new(&mut store, ty)?;assert_eq!(memory.data_size(&store), 0);@@ -870,7 +870,7 @@ fn atomic_wait_massive_timeout() -> Result<()> {config.shared_memory(true);let engine = Engine::new(&config)?;- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;let result = memory.atomic_wait32(0, 1, Some(Duration::MAX));assert_eq!(result, Ok(WaitResult::Mismatch));let result = memory.atomic_wait64(0, 1, Some(Duration::MAX));diff --git a/tests/all/missing_async.rs b/tests/all/missing_async.rsindex c6a5efa97c..88786ed988 100644--- a/tests/all/missing_async.rs+++ b/tests/all/missing_async.rs@@ -332,7 +332,7 @@ fn start_sync_then_configure_async_then_do_async() -> Result<()> {#[tokio::test]async fn async_limiter_disallows_table_new() -> Result<()> {let mut store = async_limiter_store();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;assert!(Table::new(&mut store, ty.clone(), Ref::Func(None)).is_err());Table::new_async(&mut store, ty, Ref::Func(None)).await?;Ok(())@@ -341,7 +341,7 @@ async fn async_limiter_disallows_table_new() -> Result<()> {#[tokio::test]async fn async_limiter_disallows_table_grow() -> Result<()> {let mut store = async_limiter_store();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;assert!(table.grow(&mut store, 1, Ref::Func(None)).is_err());table.grow_async(&mut store, 1, Ref::Func(None)).await?;@@ -351,7 +351,7 @@ async fn async_limiter_disallows_table_grow() -> Result<()> {#[tokio::test]async fn async_limiter_disallows_memory_new() -> Result<()> {let mut store = async_limiter_store();- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None)?;assert!(Memory::new(&mut store, ty.clone()).is_err());Memory::new_async(&mut store, ty).await?;Ok(())@@ -360,7 +360,7 @@ async fn async_limiter_disallows_memory_new() -> Result<()> {#[tokio::test]async fn async_limiter_disallows_memory_grow() -> Result<()> {let mut store = async_limiter_store();- let ty = MemoryType::new(1, None);+ let ty = MemoryType::new(1, None)?;let mem = Memory::new_async(&mut store, ty).await?;assert!(mem.grow(&mut store, 1).is_err());mem.grow_async(&mut store, 1).await?;diff --git a/tests/all/pooling_allocator.rs b/tests/all/pooling_allocator.rsindex 4ef8ef79fb..3e4c393f9e 100644--- a/tests/all/pooling_allocator.rs+++ b/tests/all/pooling_allocator.rs@@ -506,7 +506,7 @@ fn multi_memory_with_imported_memories() -> Result<()> {let mut store = Store::new(&engine, ());- let m1 = Memory::new(&mut store, MemoryType::new(0, None))?;+ let m1 = Memory::new(&mut store, MemoryType::new(0, None)?)?;let instance = Instance::new(&mut store, &module, &[m1.into()])?;let m2 = instance.get_memory(&mut store, "m2").unwrap();diff --git a/tests/all/table.rs b/tests/all/table.rsindex 6d8d9bd843..b47670546b 100644--- a/tests/all/table.rs+++ b/tests/all/table.rs@@ -3,7 +3,7 @@ use wasmtime::*;#[test]fn get_none() {let mut store = Store::<()>::default();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();match table.get(&mut store, 0) {Some(Ref::Func(None)) => {}@@ -12,10 +12,21 @@ fn get_none() {assert!(table.get(&mut store, 1).is_none());}+#[test]+fn min_greater_than_max() -> Result<()> {+ assert!(TableType::new(RefType::FUNCREF, 10, Some(5)).is_err());+ assert!(TableType::new64(RefType::FUNCREF, 10, Some(5)).is_err());++ let mut store = Store::<()>::default();+ let ty = TableType::new(RefType::FUNCREF, 5, Some(5))?;+ Table::new(&mut store, ty, Ref::Func(None))?;+ Ok(())+}+#[test]fn fill_wrong() {let mut store = Store::<()>::default();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();assert_eq!(table@@ -25,7 +36,7 @@ fn fill_wrong() {"type mismatch: value does not match table element type");- let ty = TableType::new(RefType::EXTERNREF, 1, None);+ let ty = TableType::new(RefType::EXTERNREF, 1, None).unwrap();let table = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();assert_eq!(table@@ -39,9 +50,9 @@ fn fill_wrong() {#[test]fn copy_wrong() {let mut store = Store::<()>::default();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();let table1 = Table::new(&mut store, ty, Ref::Func(None)).unwrap();- let ty = TableType::new(RefType::EXTERNREF, 1, None);+ let ty = TableType::new(RefType::EXTERNREF, 1, None).unwrap();let table2 = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();assert_eq!(Table::copy(&mut store, &table1, 0, &table2, 0, 1)@@ -55,7 +66,7 @@ fn copy_wrong() {#[cfg_attr(miri, ignore)]fn null_elem_segment_works_with_imported_table() -> Result<()> {let mut store = Store::<()>::default();- let ty = TableType::new(RefType::FUNCREF, 1, None);+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;let table = Table::new(&mut store, ty, Ref::Func(None))?;let module = Module::new(store.engine(),@@ -98,7 +109,7 @@ fn i31ref_table_new() -> Result<()> {vec![AnyRef::from_i31(&mut store, I31::default()).into()],),] {- let table_ty = TableType::new(elem_ty, 10, None);+ let table_ty = TableType::new(elem_ty, 10, None)?;for init in inits {Table::new(&mut store, table_ty.clone(), init)?;}@@ -129,7 +140,7 @@ fn i31ref_table_get() -> Result<()> {vec![AnyRef::from_i31(&mut store, I31::default()).into()],),] {- let table_ty = TableType::new(elem_ty, 10, None);+ let table_ty = TableType::new(elem_ty, 10, None)?;for init in inits {let table = Table::new(&mut store, table_ty.clone(), init.clone())?;for i in 0..10 {@@ -177,7 +188,7 @@ fn i31ref_table_set() -> Result<()> {vec![AnyRef::from_i31(&mut store, I31::wrapping_u32(42)).into()],),] {- let table_ty = TableType::new(elem_ty, 10, None);+ let table_ty = TableType::new(elem_ty, 10, None)?;for init in inits {for expected in vals.clone() {let table = Table::new(&mut store, table_ty.clone(), init.clone())?;@@ -219,7 +230,7 @@ fn i31ref_table_grow() -> Result<()> {AnyRef::from_i31(&mut store, I31::default()).into(),),] {- let table_ty = TableType::new(elem_ty, 10, None);+ let table_ty = TableType::new(elem_ty, 10, None)?;let table = Table::new(&mut store, table_ty, init)?;assert_eq!(table.size(&store), 10);for i in 10..20 {@@ -256,7 +267,7 @@ fn i31ref_table_fill() -> Result<()> {let engine = Engine::new(&config)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::I31REF, 10, None);+ let table_ty = TableType::new(RefType::I31REF, 10, None)?;let table = Table::new(&mut store, table_ty, Ref::Any(None))?;let expected = I31::wrapping_u32(42);@@ -299,7 +310,7 @@ fn i31ref_table_copy() -> Result<()> {let engine = Engine::new(&config)?;let mut store = Store::new(&engine, ());- let table_ty = TableType::new(RefType::I31REF, 10, None);+ let table_ty = TableType::new(RefType::I31REF, 10, None)?;let dst_table = Table::new(&mut store, table_ty.clone(), Ref::Any(None))?;let expected = I31::wrapping_u32(42);@@ -347,7 +358,7 @@ fn host_table_keep_type_registration() -> Result<()> {let t = Table::new(&mut store,- TableType::new(RefType::new(true, HeapType::ConcreteFunc(ty)), 1, None),+ TableType::new(RefType::new(true, HeapType::ConcreteFunc(ty)), 1, None)?,Ref::Func(None),)?;diff --git a/tests/all/threads.rs b/tests/all/threads.rsindex 66dd2ced64..dc4bf4635a 100644--- a/tests/all/threads.rs+++ b/tests/all/threads.rs@@ -32,7 +32,7 @@ fn shared_memory_failed_creation() -> Result<()> {let Ok(engine) = Engine::new(&config) else {return Ok(());};- assert!(SharedMemory::new(&engine, MemoryType::shared(1, 1)).is_err());+ assert!(SharedMemory::new(&engine, MemoryType::shared(1, 1)?).is_err());let wat = r#"(module (memory 1 1 shared))"#;let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());@@ -62,7 +62,7 @@ fn test_import_shared_memory() -> Result<()> {};let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5)?)?;let _instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;Ok(())}@@ -98,7 +98,7 @@ fn test_sharing_of_shared_memory() -> Result<()> {};let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5)?)?;let instance1 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;let instance2 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;let data = shared_memory.data();@@ -171,7 +171,7 @@ fn test_multi_memory() -> Result<()> {};let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());- let incoming_shared_memory = SharedMemory::new(&engine, MemoryType::shared(5, 10))?;+ let incoming_shared_memory = SharedMemory::new(&engine, MemoryType::shared(5, 10)?)?;let instance = Instance::new(&mut store, &module, &[incoming_shared_memory.into()])?;let owned_memory = instance.get_memory(&mut store, "owned").unwrap();let shared_memory = instance.get_shared_memory(&mut store, "shared").unwrap();@@ -208,7 +208,7 @@ fn test_grow_memory_in_multiple_threads() -> Result<()> {return Ok(());};let module = Module::new(&engine, wat)?;- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32)?)?;let mut threads = vec![];let observed_sizes = Arc::new(RwLock::new(vec![]));@@ -280,7 +280,7 @@ fn test_memory_size_accessibility() -> Result<()> {return Ok(());};let module = Module::new(&engine, wat)?;- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32)?)?;let done = Arc::new(AtomicBool::new(false));let grow_memory = shared_memory.clone();@@ -318,6 +318,6 @@ fn test_memory_size_accessibility() -> Result<()> {fn create_shared_memory_through_memory() -> Result<()> {let engine = Engine::default();let mut store = Store::new(&engine, ());- assert!(Memory::new(&mut store, MemoryType::shared(1, 1)).is_err());+ assert!(Memory::new(&mut store, MemoryType::shared(1, 1)?).is_err());Ok(())}diff --git a/tests/all/wait_notify.rs b/tests/all/wait_notify.rsindex 0460b3b388..e154bef382 100644--- a/tests/all/wait_notify.rs+++ b/tests/all/wait_notify.rs@@ -23,7 +23,7 @@ fn atomic_wait_timeout_length() -> Result<()> {};let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;let instance = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;let now = Instant::now();let func_ret = instance@@ -67,7 +67,7 @@ fn atomic_wait_notify_basic() -> Result<()> {};let module = Module::new(&engine, wat)?;let mut store = Store::new(&engine, ());- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;let instance1 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;let thread = {