feat(wit): add map type support

crates/wasm-compose/src/encoding.rs

@@ -656,6 +656,7 @@ impl<'a> TypeEncoder<'a> {
             ComponentDefinedType::Record(r) => self.record(state, r),
             ComponentDefinedType::Variant(v) => self.variant(state, v),
             ComponentDefinedType::List(ty) => self.list(state, *ty),
+            ComponentDefinedType::Map(key, value) => self.map(state, *key, *value),
             ComponentDefinedType::FixedSizeList(ty, elements) => {
                 self.fixed_size_list(state, *ty, *elements)
             }
@@ -719,6 +720,19 @@ impl<'a> TypeEncoder<'a> {
         index
     }
 
+    fn map(
+        &self,
+        state: &mut TypeState<'a>,
+        key: ct::ComponentValType,
+        value: ct::ComponentValType,
+    ) -> u32 {
+        let key = self.component_val_type(state, key);
+        let value = self.component_val_type(state, value);
+        let index = state.cur.encodable.type_count();
+        state.cur.encodable.ty().defined_type().map(key, value);
+        index
+    }
+
     fn fixed_size_list(
         &self,
         state: &mut TypeState<'a>,
@@ -1259,6 +1273,10 @@ impl DependencyRegistrar<'_, '_> {
             ComponentDefinedType::List(t)
             | ComponentDefinedType::FixedSizeList(t, _)
             | ComponentDefinedType::Option(t) => self.val_type(*t),
+            ComponentDefinedType::Map(k, v) => {
+                self.val_type(*k);
+                self.val_type(*v);
+            }
             ComponentDefinedType::Own(r) | ComponentDefinedType::Borrow(r) => {
                 self.ty(ComponentAnyTypeId::Resource(*r))
             }

crates/wasm-encoder/src/component/types.rs

@@ -620,6 +620,13 @@ impl ComponentDefinedTypeEncoder<'_> {
         ty.into().encode(self.0);
     }
 
+    /// Define a map type.
+    pub fn map(self, key: impl Into<ComponentValType>, value: impl Into<ComponentValType>) {
+        self.0.push(0x63);
+        key.into().encode(self.0);
+        value.into().encode(self.0);
+    }
+
     /// Define a fixed size list type.
     pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: u32) {
         self.0.push(0x67);

crates/wasm-encoder/src/reencode/component.rs

@@ -769,6 +769,12 @@ pub mod component_utils {
             wasmparser::ComponentDefinedType::List(t) => {
                 defined.list(reencoder.component_val_type(t));
             }
+            wasmparser::ComponentDefinedType::Map(k, v) => {
+                defined.map(
+                    reencoder.component_val_type(k),
+                    reencoder.component_val_type(v),
+                );
+            }
             wasmparser::ComponentDefinedType::FixedSizeList(t, elements) => {
                 defined.fixed_size_list(reencoder.component_val_type(t), elements);
             }

crates/wasmparser/src/features.rs

@@ -306,6 +306,12 @@ define_wasm_features! {
 
         // Compact import section proposal.
         pub compact_imports: COMPACT_IMPORTS(1 << 37) = false;
+
+        /// Support for maps in the component model proposal.
+        ///
+        /// Corresponds to the 🗺️ character in
+        /// <https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md>.
+        pub cm_map: CM_MAP(1 << 38) = false;
     }
 }
 

crates/wasmparser/src/readers/component/types.rs

@@ -446,6 +446,8 @@ pub enum ComponentDefinedType<'a> {
     Variant(Box<[VariantCase<'a>]>),
     /// The type is a list of the given value type.
     List(ComponentValType),
+    /// The type is a map of the given key and value types.
+    Map(ComponentValType, ComponentValType),
     /// The type is a fixed size list of the given value type.
     FixedSizeList(ComponentValType, u32),
     /// The type is a tuple of the given value types.
@@ -487,6 +489,7 @@ impl<'a> ComponentDefinedType<'a> {
                     .collect::<Result<_>>()?,
             ),
             0x70 => ComponentDefinedType::List(reader.read()?),
+            0x63 => ComponentDefinedType::Map(reader.read()?, reader.read()?),
             0x6f => ComponentDefinedType::Tuple(
                 reader
                     .read_iter(MAX_WASM_TUPLE_TYPES, "tuple types")?

crates/wasmparser/src/validator/component.rs

@@ -951,6 +951,9 @@ impl ComponentState {
             ComponentDefinedType::List(ty)
             | ComponentDefinedType::FixedSizeList(ty, _)
             | ComponentDefinedType::Option(ty) => types.type_named_valtype(ty, set),
+            ComponentDefinedType::Map(k, v) => {
+                types.type_named_valtype(k, set) && types.type_named_valtype(v, set)
+            }
 
             // The resource referred to by own/borrow must be named.
             ComponentDefinedType::Own(id) | ComponentDefinedType::Borrow(id) => {
@@ -3917,6 +3920,15 @@ impl ComponentState {
             crate::ComponentDefinedType::List(ty) => Ok(ComponentDefinedType::List(
                 self.create_component_val_type(ty, offset)?,
             )),
+            crate::ComponentDefinedType::Map(key, value) => {
+                if !self.features.cm_map() {
+                    bail!(offset, "Maps require the component model map feature")
+                }
+                Ok(ComponentDefinedType::Map(
+                    self.create_component_val_type(key, offset)?,
+                    self.create_component_val_type(value, offset)?,
+                ))
+            }
             crate::ComponentDefinedType::FixedSizeList(ty, elements) => {
                 if !self.features.cm_fixed_size_list() {
                     bail!(

crates/wasmparser/src/validator/component_types.rs

@@ -1468,6 +1468,8 @@ pub enum ComponentDefinedType {
     Variant(VariantType),
     /// The type is a list.
     List(ComponentValType),
+    /// The type is a map.
+    Map(ComponentValType, ComponentValType),
     /// The type is a fixed size list.
     FixedSizeList(ComponentValType, u32),
     /// The type is a tuple.
@@ -1511,6 +1513,11 @@ impl TypeData for ComponentDefinedType {
             Self::Variant(v) => v.info,
             Self::Tuple(t) => t.info,
             Self::List(ty) | Self::FixedSizeList(ty, _) | Self::Option(ty) => ty.info(types),
+            Self::Map(k, v) => {
+                let mut info = k.info(types);
+                info.combine(v.info(types), 0).unwrap();
+                info
+            }
             Self::Result { ok, err } => {
                 let default = TypeInfo::new();
                 let mut info = ok.map(|ty| ty.type_info(types)).unwrap_or(default);
@@ -1531,7 +1538,7 @@ impl ComponentDefinedType {
                 .cases
                 .values()
                 .any(|case| case.ty.map(|ty| ty.contains_ptr(types)).unwrap_or(false)),
-            Self::List(_) => true,
+            Self::List(_) | Self::Map(_, _) => true,
             Self::Tuple(t) => t.types.iter().any(|ty| ty.contains_ptr(types)),
             Self::Flags(_)
             | Self::Enum(_)
@@ -1559,7 +1566,7 @@ impl ComponentDefinedType {
                 types,
                 lowered_types,
             ),
-            Self::List(_) => {
+            Self::List(_) | Self::Map(_, _) => {
                 lowered_types.try_push(ValType::I32) && lowered_types.try_push(ValType::I32)
             }
             Self::FixedSizeList(ty, length) => {
@@ -1639,6 +1646,7 @@ impl ComponentDefinedType {
             ComponentDefinedType::Flags(_) => "flags",
             ComponentDefinedType::Option(_) => "option",
             ComponentDefinedType::List(_) => "list",
+            ComponentDefinedType::Map(_, _) => "map",
             ComponentDefinedType::FixedSizeList(_, _) => "fixed size list",
             ComponentDefinedType::Result { .. } => "result",
             ComponentDefinedType::Own(_) => "own",
@@ -1683,6 +1691,11 @@ impl ComponentDefinedType {
                 ty.lower_gc(types, abi, options, offset, array_ty.0.element_type.into())
             }
 
+            ComponentDefinedType::Map(_, _) => bail!(
+                offset,
+                "GC lowering for component `map` type is not yet implemented"
+            ),
+
             ComponentDefinedType::Tuple(ty) => ty.lower_gc(types, abi, options, offset, core),
 
             ComponentDefinedType::Flags(flags) => {
@@ -2515,6 +2528,10 @@ impl TypeAlloc {
             | ComponentDefinedType::Option(ty) => {
                 self.free_variables_valtype(ty, set);
             }
+            ComponentDefinedType::Map(k, v) => {
+                self.free_variables_valtype(k, set);
+                self.free_variables_valtype(v, set);
+            }
             ComponentDefinedType::Result { ok, err } => {
                 if let Some(ok) = ok {
                     self.free_variables_valtype(ok, set);
@@ -2657,6 +2674,9 @@ impl TypeAlloc {
             ComponentDefinedType::List(ty)
             | ComponentDefinedType::FixedSizeList(ty, _)
             | ComponentDefinedType::Option(ty) => self.type_named_valtype(ty, set),
+            ComponentDefinedType::Map(k, v) => {
+                self.type_named_valtype(k, set) && self.type_named_valtype(v, set)
+            }
 
             // own/borrow themselves don't have to be named, but the resource
             // they refer to must be named.
@@ -2849,6 +2869,10 @@ where
             | ComponentDefinedType::Option(ty) => {
                 any_changed |= self.remap_valtype(ty, map);
             }
+            ComponentDefinedType::Map(k, v) => {
+                any_changed |= self.remap_valtype(k, map);
+                any_changed |= self.remap_valtype(v, map);
+            }
             ComponentDefinedType::Result { ok, err } => {
                 if let Some(ok) = ok {
                     any_changed |= self.remap_valtype(ok, map);
@@ -3760,6 +3784,13 @@ impl<'a> SubtypeCx<'a> {
             (Variant(_), b) => bail!(offset, "expected {}, found variant", b.desc()),
             (List(a), List(b)) | (Option(a), Option(b)) => self.component_val_type(a, b, offset),
             (List(_), b) => bail!(offset, "expected {}, found list", b.desc()),
+            (Map(ak, av), Map(bk, bv)) => {
+                self.component_val_type(ak, bk, offset)
+                    .with_context(|| "type mismatch in map key")?;
+                self.component_val_type(av, bv, offset)
+                    .with_context(|| "type mismatch in map value")
+            }
+            (Map(_, _), b) => bail!(offset, "expected {}, found map", b.desc()),
             (FixedSizeList(a, asize), FixedSizeList(b, bsize)) => {
                 if asize != bsize {
                     bail!(offset, "expected fixed size {bsize}, found size {asize}")

crates/wasmprinter/src/component.rs

@@ -169,6 +169,20 @@ impl Printer<'_, '_> {
         Ok(())
     }
 
+    pub(crate) fn print_map_type(
+        &mut self,
+        state: &State,
+        key_ty: &ComponentValType,
+        value_ty: &ComponentValType,
+    ) -> Result<()> {
+        self.start_group("map ")?;
+        self.print_component_val_type(state, key_ty)?;
+        self.result.write_str(" ")?;
+        self.print_component_val_type(state, value_ty)?;
+        self.end_group()?;
+        Ok(())
+    }
+
     pub(crate) fn print_fixed_size_list_type(
         &mut self,
         state: &State,
@@ -278,6 +292,7 @@ impl Printer<'_, '_> {
             ComponentDefinedType::Record(fields) => self.print_record_type(state, fields)?,
             ComponentDefinedType::Variant(cases) => self.print_variant_type(state, cases)?,
             ComponentDefinedType::List(ty) => self.print_list_type(state, ty)?,
+            ComponentDefinedType::Map(key, value) => self.print_map_type(state, key, value)?,
             ComponentDefinedType::FixedSizeList(ty, elements) => {
                 self.print_fixed_size_list_type(state, ty, *elements)?
             }

crates/wast/src/component/binary.rs

@@ -109,6 +109,9 @@ fn encode_defined_type(encoder: ComponentDefinedTypeEncoder, ty: &ComponentDefin
         ComponentDefinedType::List(l) => {
             encoder.list(l.element.as_ref());
         }
+        ComponentDefinedType::Map(m) => {
+            encoder.map(m.key.as_ref(), m.value.as_ref());
+        }
         ComponentDefinedType::FixedSizeList(l) => {
             encoder.fixed_size_list(l.element.as_ref(), l.elements);
         }

crates/wast/src/component/expand.rs

@@ -559,6 +559,10 @@ impl<'a> Expander<'a> {
             }) => {
                 self.expand_component_val_ty(t);
             }
+            ComponentDefinedType::Map(Map { key: k, value: v }) => {
+                self.expand_component_val_ty(k);
+                self.expand_component_val_ty(v);
+            }
             ComponentDefinedType::Tuple(t) => {
                 for field in t.fields.iter_mut() {
                     self.expand_component_val_ty(field);

crates/wast/src/component/resolve.rs

@@ -566,6 +566,10 @@ impl<'a> Resolver<'a> {
             }) => {
                 self.component_val_type(t)?;
             }
+            ComponentDefinedType::Map(Map { key: k, value: v }) => {
+                self.component_val_type(k)?;
+                self.component_val_type(v)?;
+            }
             ComponentDefinedType::Tuple(t) => {
                 for field in t.fields.iter_mut() {
                     self.component_val_type(field)?;

crates/wast/src/component/types.rs

@@ -386,6 +386,7 @@ pub enum ComponentDefinedType<'a> {
     Record(Record<'a>),
     Variant(Variant<'a>),
     List(List<'a>),
+    Map(Map<'a>),
     FixedSizeList(FixedSizeList<'a>),
     Tuple(Tuple<'a>),
     Flags(Flags<'a>),
@@ -407,6 +408,8 @@ impl<'a> ComponentDefinedType<'a> {
             Ok(Self::Variant(parser.parse()?))
         } else if l.peek::<kw::list>()? {
             parse_list(parser)
+        } else if l.peek::<kw::map>()? {
+            Ok(Self::Map(parser.parse()?))
         } else if l.peek::<kw::tuple>()? {
             Ok(Self::Tuple(parser.parse()?))
         } else if l.peek::<kw::flags>()? {
@@ -451,6 +454,7 @@ impl Peek for ComponentDefinedType<'_> {
                 Some(("record", _))
                     | Some(("variant", _))
                     | Some(("list", _))
+                    | Some(("map", _))
                     | Some(("tuple", _))
                     | Some(("flags", _))
                     | Some(("enum", _))
@@ -587,6 +591,15 @@ pub struct List<'a> {
     pub element: Box<ComponentValType<'a>>,
 }
 
+/// A map type.
+#[derive(Debug)]
+pub struct Map<'a> {
+    /// The key type of the map.
+    pub key: Box<ComponentValType<'a>>,
+    /// The value type of the map.
+    pub value: Box<ComponentValType<'a>>,
+}
+
 /// A fixed size list type.
 #[derive(Debug)]
 pub struct FixedSizeList<'a> {
@@ -612,6 +625,18 @@ fn parse_list<'a>(parser: Parser<'a>) -> Result<ComponentDefinedType<'a>> {
     }
 }
 
+impl<'a> Parse<'a> for Map<'a> {
+    fn parse(parser: Parser<'a>) -> Result<Self> {
+        parser.parse::<kw::map>()?;
+        let key = parser.parse()?;
+        let value = parser.parse()?;
+        Ok(Self {
+            key: Box::new(key),
+            value: Box::new(value),
+        })
+    }
+}
+
 /// A tuple type.
 #[derive(Debug)]
 pub struct Tuple<'a> {

crates/wast/src/lib.rs

@@ -533,6 +533,7 @@ pub mod kw {
     custom_keyword!(option);
     custom_keyword!(tuple);
     custom_keyword!(list);
+    custom_keyword!(map);
     custom_keyword!(error);
     custom_keyword!(canon);
     custom_keyword!(lift);

crates/wit-component/src/encoding.rs

@@ -186,7 +186,7 @@ impl RequiredOptions {
         // If lists/strings are lowered into wasm then memory is required as
         // usual but `realloc` is also required to allow the external caller to
         // allocate space in the destination for the list/string.
-        if types.contains(TypeContents::LIST) {
+        if types.contains(TypeContents::NEEDS_MEMORY) {
             *self |= RequiredOptions::MEMORY | RequiredOptions::REALLOC;
         }
         if types.contains(TypeContents::STRING) {
@@ -200,7 +200,7 @@ impl RequiredOptions {
         // Unlike for `lower` when lifting a string/list all that's needed is
         // memory, since the string/list already resides in memory `realloc`
         // isn't needed.
-        if types.contains(TypeContents::LIST) {
+        if types.contains(TypeContents::NEEDS_MEMORY) {
             *self |= RequiredOptions::MEMORY;
         }
         if types.contains(TypeContents::STRING) {
@@ -279,7 +279,7 @@ bitflags::bitflags! {
     /// structure of a type.
     struct TypeContents: u8 {
         const STRING = 1 << 0;
-        const LIST = 1 << 1;
+        const NEEDS_MEMORY = 1 << 1;
     }
 }
 
@@ -326,7 +326,10 @@ impl TypeContents {
                     Self::for_optional_types(resolve, v.cases.iter().map(|c| c.ty.as_ref()))
                 }
                 TypeDefKind::Enum(_) => Self::empty(),
-                TypeDefKind::List(t) => Self::for_type(resolve, t) | Self::LIST,
+                TypeDefKind::List(t) => Self::for_type(resolve, t) | Self::NEEDS_MEMORY,
+                TypeDefKind::Map(k, v) => {
+                    Self::for_type(resolve, k) | Self::for_type(resolve, v) | Self::NEEDS_MEMORY
+                }
                 TypeDefKind::FixedSizeList(t, _elements) => Self::for_type(resolve, t),
                 TypeDefKind::Type(t) => Self::for_type(resolve, t),
                 TypeDefKind::Future(_) => Self::empty(),