114     module: Atom,  field
254     pub fn define_unknown_imports_as_traps(&mut self, module: &Module) -> Result<()>  in define_unknown_imports_as_traps()
258         for import in module.imports() {  in define_unknown_imports_as_traps()
261                     self.func_new(import.module(), import.name(), func_ty, move |_, _, _| {  in define_unknown_imports_as_traps()
294         module: &Module,  in define_unknown_imports_as_default_values()
300         for import in module.imports() {  in define_unknown_imports_as_default_values()
306                             import.module(),  in define_unknown_imports_as_default_values()
313                     import.module(),  in define_unknown_imports_as_default_values()
361         module: &str,  in define()
369         let key = self.import_key(module, Some(name))?;  in define()
395     fn func_insert(&mut self, module: &str, name: &str, func: HostFunc) -> Result<&mut Self>  in func_insert()
399         let key = self.import_key(module, Some(name))?;  in func_insert()
414         module: &str,  in func_new()
422         self.func_insert(module, name, HostFunc::new(&self.engine, ty, func)?)  in func_new()
439         module: &str,  in func_new_unchecked()
449         self.func_insert(module, name, func)  in func_new_unchecked()
465         module: &str,  in func_new_async()
481         self.func_insert(module, name, HostFunc::new_async(&self.engine, ty, func)?)  in func_new_async()
542         module: &str,  in func_wrap()
549         self.func_insert(module, name, func.into_func(&self.engine)?)  in func_wrap()
556         module: &str,  in func_wrap_async()
567         self.func_insert(module, name, HostFunc::wrap_async(&self.engine, func)?)  in func_wrap_async()
767     pub fn module(  in module()  method
771         module: &Module,  in module()
787         match ModuleKind::categorize(module)? {  in module()
792                     module,  in module()
818                 let instance = self.instantiate(&mut store, &module)?;  in module()
841         module: &Module,  in module_async()
852         match ModuleKind::categorize(module)? {  in module_async()
856                 module,  in module_async()
882                 let instance = self.instantiate_async(&mut store, &module).await?;  in module_async()
904         module: &Module,  in command()
911         for export in module.exports() {  in command()
913                 let instance_pre = self.instantiate_pre(module)?;  in command()
965         module: &str,  in alias()
970         let src = self.import_key(module, Some(name))?;  in alias()
988     pub fn alias_module(&mut self, module: &str, as_module: &str) -> Result<()> {  in alias_module()
989         let module = self.pool.insert(module)?;  in alias_module()  localVariable
994             .filter(|(key, _def)| key.module == module)  in alias_module()
1000                     module: as_module,  in alias_module()
1011             let module = &self.pool[key.module];  in insert()  localVariable
1022     fn import_key(&mut self, module: &str, name: Option<&str>) -> Result<ImportKey, OutOfMemory> {  in import_key()
1024             module: self.pool.insert(module)?,  in import_key()
1082         module: &Module,  in instantiate()
1087         self._instantiate_pre(module, Some(store.as_context_mut().0))?  in instantiate()
1097         module: &Module,  in instantiate_async()
1102         self._instantiate_pre(module, Some(store.as_context_mut().0))?  in instantiate_async()
1154     pub fn instantiate_pre(&self, module: &Module) -> Result<InstancePre<T>>  in instantiate_pre()
1158         self._instantiate_pre(module, None)  in instantiate_pre()
1174         module: &Module,  in _instantiate_pre()
1180         let mut imports: TryVec<_> = module  in _instantiate_pre()
1189         unsafe { InstancePre::new(module, imports) }  in _instantiate_pre()
1216                 &self.pool[key.module],  in iter()
1237         module: &str,  in get()
1244         match self._get(module, name) {  in get()
1251     fn _get(&self, module: &str, name: &str) -> Option<&Definition> {  in _get()
1253             module: self.pool.get_atom(module)?,  in _get()
1299         match self._get(import.module(), import.name()) {  in _get_by_import()
1315     pub fn get_default(&self, mut store: impl AsContextMut<Data = T>, module: &str) -> Result<Func>  in get_default()
1319         if let Some(external) = self.get(&mut store, module, "").map(Some).or_else(|e| {  in get_default()
1334             .get(&mut store, module, "_start")  in get_default()
1452     fn categorize(module: &Module) -> Result<ModuleKind> {  in categorize()
1453         let command_start = module.get_export("_start");  in categorize()
1454         let reactor_start = module.get_export("_initialize");  in categorize()
1490     module: String,  field
1498             module: import.module().to_string(),  in new()
1505     pub fn module(&self) -> &str {  in module()  method
1506         &self.module  in module()
1525             self.module, self.name,  in fmt()