use wasmparser Map instead of std in environ::component::info

Author: gionut

crates/environ/src/component/info.rs

@@ -51,7 +51,7 @@ use crate::prelude::*;
 use crate::{EntityIndex, ModuleInternedTypeIndex, PrimaryMap, WasmValType};
 use cranelift_entity::packed_option::PackedOption;
 use serde_derive::{Deserialize, Serialize};
-use std::collections::HashMap;
+use wasmparser::collections::Map;
 
 /// Metadata as a result of compiling a component.
 pub struct ComponentTranslation {
@@ -66,26 +66,24 @@ pub struct ComponentTranslation {
 /// The elements within [`Self::instances`] correspond to the runtime component
 /// instances which directly instantiate core modules. Each element should contain the information
 /// needed to identify the source of their imports. Specific information about how that is
-/// implemented is available in [`dfg::RuntimeComponentInstanceStructure`]
+/// implemented is available in [`info::RuntimeComponentInstanceStructure`]
 #[derive(Serialize, Deserialize, Default, Clone, Debug)]
 pub struct RootComponentInstanceStructure {
     /// Subcomponent instances that instantiate core modules directly. The keys are the [`RuntimeComponentInstanceStructure.path`]
-    pub instances: HashMap<String, RuntimeComponentInstanceStructure>,
+    pub instances: Map<String, RuntimeComponentInstanceStructure>,
 
     /// Re-mapping table from the [`RuntimeComponentInstanceIndex`] to [`RuntimeComponentInstanceStructure.path`]
-    pub table: HashMap<u32, String>,
+    pub table: Map<u32, String>,
 }
 
 impl RootComponentInstanceStructure {
     /// todo:
-    pub fn runtime_instances_mut(
-        &mut self,
-    ) -> &mut HashMap<String, RuntimeComponentInstanceStructure> {
+    pub fn runtime_instances_mut(&mut self) -> &mut Map<String, RuntimeComponentInstanceStructure> {
         &mut self.instances
     }
 
     /// todo:
-    pub fn table_mut(&mut self) -> &mut HashMap<u32, String> {
+    pub fn table_mut(&mut self) -> &mut Map<u32, String> {
         &mut self.table
     }
 }
@@ -96,11 +94,11 @@ pub struct CoreInstanceStructure {
     /// Hex encoded sha256 digest of the core module binary.
     pub module_code_digest: String,
     /// Exported items from this core instance
-    pub core_exports: HashMap<u32, String>,
+    pub core_exports: Map<u32, String>,
     /// Imported items by this core instance
-    pub core_imports: HashMap<u32, String>,
+    pub core_imports: Map<u32, String>,
     /// The sources of the imported items
-    pub sources: HashMap<u32, Source>,
+    pub sources: Map<u32, Source>,
 }
 
 /// Represents a core export definition in the instantiation graph, used to track the source of
@@ -141,11 +139,11 @@ pub struct RuntimeComponentInstanceStructure {
     pub path: String,
 
     /// Maps to the core definitions that are being exported by this component.
-    pub component_exports: HashMap<u32, Source>,
+    pub component_exports: Map<u32, Source>,
 
     /// Map of the core instances associated with this component instance.
     /// The index represents the core instance index within the index space of this component.
-    pub core_instances: HashMap<u32, CoreInstanceStructure>,
+    pub core_instances: Map<u32, CoreInstanceStructure>,
 }
 
 /// Run-time-type-information about a `Component`, its structure, and how to

crates/environ/src/component/translate/inline.rs

@@ -52,6 +52,7 @@ use core::str::FromStr;
 use sha2::{Digest, Sha256};
 use std::borrow::Cow;
 use std::ops::Index;
+use wasmparser::collections::Map;
 use wasmparser::component_types::{ComponentAnyTypeId, ComponentCoreModuleTypeId};
 
 pub(super) fn run(
@@ -377,7 +378,7 @@ fn record_core_def_from_export(
     name: &str,
     def: ComponentItemDef,
     types: &ComponentTypesBuilder,
-    map: &mut HashMap<String, dfg::CoreDef>,
+    map: &mut Map<String, dfg::CoreDef>,
 ) -> Result<()> {
     match &def {
         ComponentItemDef::Instance(instance) => match instance {
@@ -502,7 +503,7 @@ impl<'a> Inliner<'a> {
         exports: &IndexMap<&str, ComponentItemDef>,
         fr: &mut InlinerFrame,
     ) -> Result<()> {
-        let mut comp_exports: HashMap<String, dfg::CoreDef> = HashMap::new();
+        let mut comp_exports: Map<String, dfg::CoreDef> = Map::new();
         for (name, item) in exports.iter() {
             record_core_def_from_export(name, item.clone(), types, &mut comp_exports)?;
         }
@@ -1313,8 +1314,8 @@ impl<'a> Inliner<'a> {
             // and an initializer is recorded to indicate that it's being
             // instantiated.
             ModuleInstantiate(module, args) => {
-                let mut core_imports: HashMap<u32, String> = Default::default();
-                let mut sources: HashMap<u32, Source> = Default::default();
+                let mut core_imports: Map<u32, String> = Default::default();
+                let mut sources: Map<u32, Source> = Default::default();
 
                 let (instance_module, init) = match &frame.modules[*module] {
                     ModuleDef::Static(idx, _ty) => {
@@ -1386,7 +1387,7 @@ impl<'a> Inliner<'a> {
                 match &frame.modules[*module] {
                     ModuleDef::Static(midx, _ty) => {
                         let core_instance = frame.module_instances.len() as u32;
-                        let mut core_exports: HashMap<u32, String> = HashMap::new();
+                        let mut core_exports: Map<u32, String> = Map::new();
                         let mut count = 0;
                         for (name, &entity) in self.nested_modules[*midx].module.exports.iter() {
                             core_exports.insert(count, name.to_string());