Removed duplicated iterator

lib/js-api/src/iterators.rs

@@ -1,114 +0,0 @@
-use wasmer_types::{
-    ExportType, ExternType, FunctionType, GlobalType, ImportType, MemoryType, TableType,
-};
-
-// Code inspired from
-// https://www.reddit.com/r/rust/comments/9vspv4/extending_iterators_ergonomically/
-
-/// This iterator allows us to iterate over the exports
-/// and offer nice API ergonomics over it.
-pub struct ExportsIterator<I: Iterator<Item = ExportType> + Sized> {
-    pub(crate) iter: I,
-    pub(crate) size: usize,
-}
-
-impl<I: Iterator<Item = ExportType> + Sized> ExactSizeIterator for ExportsIterator<I> {
-    // We can easily calculate the remaining number of iterations.
-    fn len(&self) -> usize {
-        self.size
-    }
-}
-
-impl<I: Iterator<Item = ExportType> + Sized> ExportsIterator<I> {
-    /// Get only the functions
-    pub fn functions(self) -> impl Iterator<Item = ExportType<FunctionType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Function(ty) => Some(ExportType::new(extern_.name(), ty.clone())),
-            _ => None,
-        })
-    }
-    /// Get only the memories
-    pub fn memories(self) -> impl Iterator<Item = ExportType<MemoryType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Memory(ty) => Some(ExportType::new(extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-    /// Get only the tables
-    pub fn tables(self) -> impl Iterator<Item = ExportType<TableType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Table(ty) => Some(ExportType::new(extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-    /// Get only the globals
-    pub fn globals(self) -> impl Iterator<Item = ExportType<GlobalType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Global(ty) => Some(ExportType::new(extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-}
-
-impl<I: Iterator<Item = ExportType> + Sized> Iterator for ExportsIterator<I> {
-    type Item = ExportType;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-/// This iterator allows us to iterate over the imports
-/// and offer nice API ergonomics over it.
-pub struct ImportsIterator<I: Iterator<Item = ImportType> + Sized> {
-    pub(crate) iter: I,
-    pub(crate) size: usize,
-}
-
-impl<I: Iterator<Item = ImportType> + Sized> ExactSizeIterator for ImportsIterator<I> {
-    // We can easily calculate the remaining number of iterations.
-    fn len(&self) -> usize {
-        self.size
-    }
-}
-
-impl<I: Iterator<Item = ImportType> + Sized> ImportsIterator<I> {
-    /// Get only the functions
-    pub fn functions(self) -> impl Iterator<Item = ImportType<FunctionType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Function(ty) => Some(ImportType::new(
-                extern_.module(),
-                extern_.name(),
-                ty.clone(),
-            )),
-            _ => None,
-        })
-    }
-    /// Get only the memories
-    pub fn memories(self) -> impl Iterator<Item = ImportType<MemoryType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Memory(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-    /// Get only the tables
-    pub fn tables(self) -> impl Iterator<Item = ImportType<TableType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Table(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-    /// Get only the globals
-    pub fn globals(self) -> impl Iterator<Item = ImportType<GlobalType>> + Sized {
-        self.iter.filter_map(|extern_| match extern_.ty() {
-            ExternType::Global(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
-            _ => None,
-        })
-    }
-}
-
-impl<I: Iterator<Item = ImportType> + Sized> Iterator for ImportsIterator<I> {
-    type Item = ImportType;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}

lib/js-api/src/lib.rs

@@ -93,7 +93,6 @@ mod exports;
 mod externals;
 mod import_object;
 mod instance;
-mod iterators;
 mod module;
 #[cfg(feature = "wasm-types-polyfill")]
 mod module_info_polyfill;

lib/js-api/src/module.rs

@@ -1,5 +1,4 @@
 use crate::export::{Export, VMFunction};
-use crate::iterators::{ExportsIterator, ImportsIterator};
 use crate::resolver::Resolver;
 use crate::store::Store;
 use crate::types::{ExportType, ImportType};
@@ -14,7 +13,8 @@ use std::io;
 use std::path::Path;
 use thiserror::Error;
 use wasmer_types::{
-    ExternType, FunctionType, GlobalType, MemoryType, Mutability, Pages, TableType, Type,
+    ExportsIterator, ExternType, FunctionType, GlobalType, ImportsIterator, MemoryType, Mutability,
+    Pages, TableType, Type,
 };
 
 #[derive(Error, Debug)]
@@ -170,10 +170,12 @@ impl Module {
             (
                 Some(ModuleTypeHints {
                     imports: info
+                        .info
                         .imports()
                         .map(|import| import.ty().clone())
                         .collect::<Vec<_>>(),
                     exports: info
+                        .info
                         .exports()
                         .map(|export| export.ty().clone())
                         .collect::<Vec<_>>(),
@@ -370,10 +372,7 @@ impl Module {
             })
             .collect::<Vec<_>>()
             .into_iter();
-        ImportsIterator {
-            iter,
-            size: imports.length() as usize,
-        }
+        ImportsIterator::new(iter, imports.length() as usize)
     }
 
     /// Set the type hints for this module.
@@ -476,10 +475,7 @@ impl Module {
             })
             .collect::<Vec<_>>()
             .into_iter();
-        ExportsIterator {
-            iter,
-            size: exports.length() as usize,
-        }
+        ExportsIterator::new(iter, exports.length() as usize)
     }
 
     // /// Get the custom sections of the module given a `name`.

lib/js-api/src/module_info_polyfill.rs

@@ -5,7 +5,6 @@
 //! for the Wasm imports and exports.
 //!  
 //! https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md
-use crate::iterators::{ExportsIterator, ImportsIterator};
 use core::convert::TryFrom;
 use std::vec::Vec;
 use wasmer_types::entity::{EntityRef, PrimaryMap};
@@ -252,70 +251,6 @@ impl ModuleInfoPolyfill {
         self.info.name = Some(name.to_string());
         Ok(())
     }
-
-    /// Get the export types of the module
-    pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
-        let iter = self.info.exports.iter().map(move |(name, export_index)| {
-            let extern_type = match export_index {
-                ExportIndex::Function(i) => {
-                    let signature = self.info.functions.get(*i).unwrap();
-                    let func_type = self.info.signatures.get(*signature).unwrap();
-                    ExternType::Function(func_type.clone())
-                }
-                ExportIndex::Table(i) => {
-                    let table_type = self.info.tables.get(*i).unwrap();
-                    ExternType::Table(*table_type)
-                }
-                ExportIndex::Memory(i) => {
-                    let memory_type = self.info.memories.get(*i).unwrap();
-                    ExternType::Memory(*memory_type)
-                }
-                ExportIndex::Global(i) => {
-                    let global_type = self.info.globals.get(*i).unwrap();
-                    ExternType::Global(*global_type)
-                }
-            };
-            ExportType::new(name, extern_type)
-        });
-        ExportsIterator {
-            iter,
-            size: self.info.exports.len(),
-        }
-    }
-
-    /// Get the import types of the module
-    pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
-        let iter = self
-            .info
-            .imports
-            .iter()
-            .map(move |((module, field, _), import_index)| {
-                let extern_type = match import_index {
-                    ImportIndex::Function(i) => {
-                        let signature = self.info.functions.get(*i).unwrap();
-                        let func_type = self.info.signatures.get(*signature).unwrap();
-                        ExternType::Function(func_type.clone())
-                    }
-                    ImportIndex::Table(i) => {
-                        let table_type = self.info.tables.get(*i).unwrap();
-                        ExternType::Table(*table_type)
-                    }
-                    ImportIndex::Memory(i) => {
-                        let memory_type = self.info.memories.get(*i).unwrap();
-                        ExternType::Memory(*memory_type)
-                    }
-                    ImportIndex::Global(i) => {
-                        let global_type = self.info.globals.get(*i).unwrap();
-                        ExternType::Global(*global_type)
-                    }
-                };
-                ImportType::new(module, field, extern_type)
-            });
-        ImportsIterator {
-            iter,
-            size: self.info.imports.len(),
-        }
-    }
 }
 
 fn transform_err(err: BinaryReaderError) -> String {