Remove unsupported functions

Remove public functions that cannot be implemented with the new wasm3
public API.

Author: jimpo

src/function.rs

@@ -100,11 +100,6 @@ where
     Args: WasmArgs,
     Ret: WasmType,
 {
-    /// The name of the import module of this function.
-    pub fn import_module_name(&self) -> &str {
-        unsafe { cstr_to_str(self.raw.as_ref().import.moduleUtf8) }
-    }
-
     /// The name of this function.
     pub fn name(&self) -> &str {
         unsafe { cstr_to_str(self.raw.as_ref().name) }

src/module.rs

@@ -164,36 +164,6 @@ impl<'rt> Module<'rt> {
         Function::from_raw(self.rt, func).and_then(Function::compile)
     }
 
-    /// Looks up a function by its index in this module.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error in the following situations:
-    ///
-    /// * a memory allocation failed
-    /// * the index is out of bounds
-    /// * the function has been found but the signature did not match
-    pub fn function<Args, Ret>(&self, function_index: usize) -> Result<Function<'rt, Args, Ret>>
-    where
-        Args: crate::WasmArgs,
-        Ret: crate::WasmType,
-    {
-        let func = unsafe {
-            slice::from_raw_parts_mut(
-                if (*self.raw).functions.is_null() {
-                    NonNull::dangling().as_ptr()
-                } else {
-                    (*self.raw).functions
-                },
-                (*self.raw).numFunctions as usize,
-            )
-            .get(function_index)
-            .map(NonNull::from)
-            .ok_or(Error::FunctionNotFound)?
-        };
-        Function::from_raw(self.rt, func).and_then(Function::compile)
-    }
-
     /// The name of this module.
     pub fn name(&self) -> &str {
         unsafe { cstr_to_str((*self.raw).name) }

src/runtime.rs

@@ -91,46 +91,6 @@ impl Runtime {
             .unwrap_or(Err(Error::FunctionNotFound))
     }
 
-    /// Searches for a module with the given name in the runtime's loaded modules.
-    ///
-    /// Using this over searching through [`Runtime::modules`] is a bit more efficient as it
-    /// works on the underlying CStrings directly and doesn't require an upfront length calculation.
-    ///
-    /// [`Runtime::modules`]: struct.Runtime.html#method.modules
-    pub fn find_module<'rt>(&'rt self, name: &str) -> Result<Module<'rt>> {
-        unsafe {
-            let mut module = ptr::NonNull::new(self.raw.as_ref().modules);
-            while let Some(raw_mod) = module {
-                if eq_cstr_str(raw_mod.as_ref().name, name) {
-                    return Ok(Module::from_raw(self, raw_mod.as_ptr()));
-                }
-
-                module = ptr::NonNull::new(raw_mod.as_ref().next);
-            }
-            Err(Error::ModuleNotFound)
-        }
-    }
-
-    /// Returns an iterator over the runtime's loaded modules.
-    pub fn modules<'rt>(&'rt self) -> impl Iterator<Item = Module<'rt>> + 'rt {
-        // pointer could get invalidated if modules can become unloaded
-        // pushing new modules into the runtime while this iterator exists is fine as its backed by a linked list meaning it wont get invalidated.
-        let mut module = unsafe { ptr::NonNull::new(self.raw.as_ref().modules) };
-        core::iter::from_fn(move || {
-            let next = unsafe { module.and_then(|module| ptr::NonNull::new(module.as_ref().next)) };
-            mem::replace(&mut module, next).map(|raw| Module::from_raw(self, raw.as_ptr()))
-        })
-    }
-
-    /// Resizes the number of allocatable pages to num_pages.
-    ///
-    /// # Errors
-    ///
-    /// This function will error out if it failed to resize memory allocation.
-    pub fn resize_memory(&self, num_pages: u32) -> Result<()> {
-        Error::from_ffi_res(unsafe { ffi::ResizeMemory(self.raw.as_ptr(), num_pages) })
-    }
-
     /// Returns the raw memory of this runtime.
     ///
     /// # Safety
@@ -160,26 +120,6 @@ impl Runtime {
         };
         ptr::slice_from_raw_parts_mut(data, len)
     }
-
-    /// Returns the stack of this runtime.
-    pub fn stack(&self) -> *const [ffi::m3slot_t] {
-        unsafe {
-            ptr::slice_from_raw_parts(
-                self.raw.as_ref().stack.cast::<ffi::m3slot_t>(),
-                self.raw.as_ref().numStackSlots as usize,
-            )
-        }
-    }
-
-    /// Returns the stack of this runtime.
-    pub fn stack_mut(&self) -> *mut [ffi::m3slot_t] {
-        unsafe {
-            ptr::slice_from_raw_parts_mut(
-                self.raw.as_ref().stack.cast::<ffi::m3slot_t>(),
-                self.raw.as_ref().numStackSlots as usize,
-            )
-        }
-    }
 }
 
 impl Runtime {