Reduce verbosity in wasmparser Types API

This additionally applies to `TypesRef` and this PR applies a few
changes:

* Going from a `TypeId` to a `Type` is now done with `&types[id]` or
  `types.get(id)` instead of `type_from_id(id).unwrap()`.
* All index-based accessors return a `T` instead of `Option<T>`.
  Fallibility is possible through the `*_count()` methods for embedders
  to test if necessary, but otherwise almost all accesses were followed
  by `.unwrap()` anyway.
* Conversions from `Type` to a sub-component which were previously
  `as_foo_type(&self) -> Option<&Foo>` are now expressed as
  `unwrap_foo(&self) -> &Foo`. This renames `as` to `unwrap` to
  highlight the panicking behavior and additionally drops the `_type`
  suffix since that's implied on everything anyway.
* The `type_at` function and its `core: bool` argument are removed in
  favor of `core_type_at` and `component_type_at` functions.
* The `func_type_at` function was removed as it can be achieved through
  combining other functions.
* Some methods which returned `&T` changed to return a `TypeId` which
  represents `T` for consistency.

This is inspired by comments on #1094 and is something I've wanted to
address for awhile and will ideally make the `Types` API a bit more
ergonomic to use with fewer conversions and less `.unwrap()`
boilerplate without any loss of functionality.

Author: alexcrichton

crates/wasm-compose/src/composer.rs

@@ -248,7 +248,7 @@ impl<'a> CompositionGraphBuilder<'a> {
         let (_, component) = self.graph.get_component_of_instance(*instance_id).unwrap();
         match component.export_by_name(export) {
             Some((export_index, kind, index)) if kind == ComponentExternalKind::Instance => {
-                let export_ty = component.types.component_instance_at(index).unwrap();
+                let export_ty = component.types.component_instance_at(index);
                 if !ComponentEntityType::is_subtype_of(
                     &ComponentEntityType::Instance(export_ty),
                     component.types(),
@@ -275,11 +275,9 @@ impl<'a> CompositionGraphBuilder<'a> {
         let component = self.graph.get_component(r.component).unwrap();
         let (name, ty) = component.import(r.import).unwrap();
         match ty {
-            ComponentTypeRef::Instance(index) => (
-                component,
-                name,
-                component.types.id_from_type_index(index, false).unwrap(),
-            ),
+            ComponentTypeRef::Instance(index) => {
+                (component, name, component.types.component_type_at(index))
+            }
             _ => unreachable!("should not have an instance import ref to a non-instance import"),
         }
     }

crates/wasm-compose/src/encoding.rs

@@ -195,11 +195,11 @@ impl<'a> TypeEncoder<'a> {
     ) -> EntityType {
         match ty {
             wasmparser::types::EntityType::Func(id) => {
-                let ty = self.0.type_from_id(id).unwrap();
+                let ty = &self.0[id];
                 let idx = match types.entry(PtrKey(ty)) {
                     Entry::Occupied(e) => *e.get(),
                     Entry::Vacant(e) => {
-                        let ty = ty.as_func_type().unwrap();
+                        let ty = ty.unwrap_func();
                         let index = encodable.type_count();
                         encodable.ty().function(
                             ty.params().iter().copied().map(Self::val_type),
@@ -214,11 +214,11 @@ impl<'a> TypeEncoder<'a> {
             wasmparser::types::EntityType::Memory(ty) => EntityType::Memory(Self::memory_type(ty)),
             wasmparser::types::EntityType::Global(ty) => EntityType::Global(Self::global_type(ty)),
             wasmparser::types::EntityType::Tag(id) => {
-                let ty = self.0.type_from_id(id).unwrap();
+                let ty = &self.0[id];
                 let idx = match types.entry(PtrKey(ty)) {
                     Entry::Occupied(e) => *e.get(),
                     Entry::Vacant(e) => {
-                        let ty = ty.as_func_type().unwrap();
+                        let ty = ty.unwrap_func();
                         let index = encodable.type_count();
                         encodable.ty().function(
                             ty.params().iter().copied().map(Self::val_type),
@@ -341,11 +341,11 @@ impl<'a> TypeEncoder<'a> {
         types: &mut TypeMap<'a>,
         id: TypeId,
     ) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
+        let ty = &self.0[id];
         match types.entry(PtrKey(ty)) {
             Entry::Occupied(e) => *e.get(),
             Entry::Vacant(e) => {
-                let ty = ty.as_module_type().unwrap();
+                let ty = ty.unwrap_module();
 
                 let module = self.module(
                     ty.imports
@@ -367,11 +367,11 @@ impl<'a> TypeEncoder<'a> {
         types: &mut TypeMap<'a>,
         id: TypeId,
     ) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
+        let ty = &self.0[id];
         match types.entry(PtrKey(ty)) {
             Entry::Occupied(e) => *e.get(),
             Entry::Vacant(e) => {
-                let ty = ty.as_component_instance_type().unwrap();
+                let ty = ty.unwrap_component_instance();
                 let instance = self.instance(ty.exports.iter().map(|(n, t)| (n.as_str(), *t)));
                 let index = encodable.type_count();
                 encodable.ty().instance(&instance);
@@ -386,11 +386,11 @@ impl<'a> TypeEncoder<'a> {
         types: &mut TypeMap<'a>,
         id: TypeId,
     ) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
+        let ty = &self.0[id];
         match types.entry(PtrKey(ty)) {
             Entry::Occupied(e) => *e.get(),
             Entry::Vacant(e) => {
-                let ty = ty.as_component_type().unwrap();
+                let ty = ty.unwrap_component();
 
                 let component = self.component(
                     ty.imports.iter().map(|(n, t)| (n.as_str(), *t)),
@@ -410,12 +410,12 @@ impl<'a> TypeEncoder<'a> {
         types: &mut TypeMap<'a>,
         id: TypeId,
     ) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
+        let ty = &self.0[id];
         if let Some(idx) = types.get(&PtrKey(ty)) {
             return *idx;
         }
 
-        let func_ty = ty.as_component_func_type().unwrap();
+        let func_ty = ty.unwrap_component_func();
 
         let params = func_ty
             .params
@@ -459,9 +459,7 @@ impl<'a> TypeEncoder<'a> {
     }
 
     fn ty(&self, encodable: &mut impl Encodable, types: &mut TypeMap<'a>, id: TypeId) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
-
-        match ty {
+        match &self.0[id] {
             Type::Sub(_) | Type::Instance(_) => {
                 unreachable!()
             }
@@ -496,12 +494,12 @@ impl<'a> TypeEncoder<'a> {
         types: &mut TypeMap<'a>,
         id: TypeId,
     ) -> u32 {
-        let ty = self.0.type_from_id(id).unwrap();
+        let ty = &self.0[id];
         if let Some(idx) = types.get(&PtrKey(ty)) {
             return *idx;
         }
 
-        let defined_ty = ty.as_defined_type().unwrap();
+        let defined_ty = ty.unwrap_defined();
 
         let index = match defined_ty {
             wasmparser::types::ComponentDefinedType::Primitive(ty) => {
@@ -694,7 +692,7 @@ impl<'a> TypeEncoder<'a> {
         let export = self.component_entity_type(encoded, types, export);
         if let Some(id) = id {
             // Update the index in the type map to point to this export
-            let ty = self.0.type_from_id(id).unwrap();
+            let ty = &self.0[id];
             types.insert(PtrKey(ty), encoded.type_count());
         }
         export
@@ -736,12 +734,8 @@ impl ArgumentImport<'_> {
         // If the existing import is an instance, convert this argument import to
         // a merged instance import.
         if let ArgumentImportKind::Item(component, ComponentEntityType::Instance(id)) = &self.kind {
-            let exports = component
-                .types
-                .type_from_id(*id)
-                .unwrap()
-                .as_component_instance_type()
-                .unwrap()
+            let exports = component.types[*id]
+                .unwrap_component_instance()
                 .exports
                 .iter();
 
@@ -763,12 +757,8 @@ impl ArgumentImport<'_> {
                 ArgumentImportKind::Instance(exports),
                 ArgumentImportKind::Item(new_component, ComponentEntityType::Instance(id)),
             ) => {
-                for (name, new_type) in new_component
-                    .types
-                    .type_from_id(id)
-                    .unwrap()
-                    .as_component_instance_type()
-                    .unwrap()
+                for (name, new_type) in new_component.types[id]
+                    .unwrap_component_instance()
                     .exports
                     .iter()
                 {

crates/wasm-compose/src/graph.rs

@@ -286,9 +286,7 @@ impl<'a> Component<'a> {
                     return false;
                 }
                 ComponentEntityType::is_subtype_of(
-                    &ComponentEntityType::Instance(
-                        self.types.component_instance_at(*index).unwrap(),
-                    ),
+                    &ComponentEntityType::Instance(self.types.component_instance_at(*index)),
                     self.types(),
                     &ComponentEntityType::Instance(ty),
                     types,
@@ -300,13 +298,7 @@ impl<'a> Component<'a> {
     /// Checks to see if an instance of this component would be a
     /// subtype of the given instance type.
     pub(crate) fn is_instance_subtype_of(&self, ty: TypeId, types: TypesRef) -> bool {
-        let exports = types
-            .type_from_id(ty)
-            .unwrap()
-            .as_component_instance_type()
-            .unwrap()
-            .exports
-            .iter();
+        let exports = types[ty].unwrap_component_instance().exports.iter();
 
         for (k, b) in exports {
             match self.exports.get_full(k.as_str()) {

crates/wasmparser/src/validator.rs

@@ -1441,67 +1441,52 @@ mod tests {
         assert_eq!(types.instance_count(), 0);
         assert_eq!(types.value_count(), 0);
 
-        match types.func_type_at(0) {
-            Some(ty) => {
-                assert_eq!(ty.params(), [ValType::I32, ValType::I64]);
-                assert_eq!(ty.results(), [ValType::I32]);
-            }
-            _ => unreachable!(),
-        }
+        let ty = types[types.core_type_at(0)].unwrap_func();
+        assert_eq!(ty.params(), [ValType::I32, ValType::I64]);
+        assert_eq!(ty.results(), [ValType::I32]);
 
-        match types.func_type_at(1) {
-            Some(ty) => {
-                assert_eq!(ty.params(), [ValType::I64, ValType::I32]);
-                assert_eq!(ty.results(), []);
-            }
-            _ => unreachable!(),
-        }
+        let ty = types[types.core_type_at(1)].unwrap_func();
+        assert_eq!(ty.params(), [ValType::I64, ValType::I32]);
+        assert_eq!(ty.results(), []);
 
         assert_eq!(
             types.memory_at(0),
-            Some(MemoryType {
+            MemoryType {
                 memory64: false,
                 shared: false,
                 initial: 1,
                 maximum: Some(5)
-            })
+            }
         );
 
         assert_eq!(
             types.table_at(0),
-            Some(TableType {
+            TableType {
                 initial: 10,
                 maximum: None,
                 element_type: RefType::FUNCREF,
-            })
+            }
         );
 
         assert_eq!(
             types.global_at(0),
-            Some(GlobalType {
+            GlobalType {
                 content_type: ValType::I32,
                 mutable: true
-            })
+            }
         );
 
-        let id = types.function_at(0).unwrap();
-        match types.type_from_id(id).unwrap().as_func_type() {
-            Some(ty) => {
-                assert_eq!(ty.params(), [ValType::I32, ValType::I64]);
-                assert_eq!(ty.results(), [ValType::I32]);
-            }
-            _ => unreachable!(),
-        }
+        let id = types.function_at(0);
+        let ty = types[id].unwrap_func();
+        assert_eq!(ty.params(), [ValType::I32, ValType::I64]);
+        assert_eq!(ty.results(), [ValType::I32]);
 
-        match types.tag_at(0) {
-            Some(ty) => {
-                assert_eq!(ty.params(), [ValType::I64, ValType::I32]);
-                assert_eq!(ty.results(), []);
-            }
-            _ => unreachable!(),
-        }
+        let ty = types.tag_at(0);
+        let ty = types[ty].unwrap_func();
+        assert_eq!(ty.params(), [ValType::I64, ValType::I32]);
+        assert_eq!(ty.results(), []);
 
-        assert_eq!(types.element_at(0), Some(RefType::FUNCREF));
+        assert_eq!(types.element_at(0), RefType::FUNCREF);
 
         Ok(())
     }
@@ -1525,24 +1510,18 @@ mod tests {
 
         let types = validator.validate_all(&bytes)?;
 
-        let t_id = types.id_from_type_index(0, false).unwrap();
-        let a1_id = types.id_from_type_index(1, false).unwrap();
-        let a2_id = types.id_from_type_index(2, false).unwrap();
+        let t_id = types.component_type_at(0);
+        let a1_id = types.component_type_at(1);
+        let a2_id = types.component_type_at(2);
 
         // The ids should all be the same
         assert!(t_id == a1_id);
         assert!(t_id == a2_id);
         assert!(a1_id == a2_id);
 
         // However, they should all point to the same type
-        assert!(std::ptr::eq(
-            types.type_from_id(t_id).unwrap(),
-            types.type_from_id(a1_id).unwrap()
-        ));
-        assert!(std::ptr::eq(
-            types.type_from_id(t_id).unwrap(),
-            types.type_from_id(a2_id).unwrap()
-        ));
+        assert!(std::ptr::eq(&types[t_id], &types[a1_id],));
+        assert!(std::ptr::eq(&types[t_id], &types[a2_id],));
 
         Ok(())
     }
@@ -1566,24 +1545,18 @@ mod tests {
 
         let types = validator.validate_all(&bytes)?;
 
-        let t_id = types.id_from_type_index(0, false).unwrap();
-        let a1_id = types.id_from_type_index(1, false).unwrap();
-        let a2_id = types.id_from_type_index(2, false).unwrap();
+        let t_id = types.component_type_at(0);
+        let a1_id = types.component_type_at(1);
+        let a2_id = types.component_type_at(2);
 
         // The ids should all be the same
         assert!(t_id != a1_id);
         assert!(t_id != a2_id);
         assert!(a1_id != a2_id);
 
         // However, they should all point to the same type
-        assert!(std::ptr::eq(
-            types.type_from_id(t_id).unwrap(),
-            types.type_from_id(a1_id).unwrap()
-        ));
-        assert!(std::ptr::eq(
-            types.type_from_id(t_id).unwrap(),
-            types.type_from_id(a2_id).unwrap()
-        ));
+        assert!(std::ptr::eq(&types[t_id], &types[a1_id],));
+        assert!(std::ptr::eq(&types[t_id], &types[a2_id],));
 
         Ok(())
     }