Initial implementation of resource types

This commit is an initial implementation of resource types for the
component model. The support added in this commit encompasses:

* `wasmparser` - parsing and validation of resource types
* `wasmprinter` - converting binary to text for resource types
* `wast` - parsing the text format for resource types
* `wasm-encoder` - writing the binary format for resource types

Other crates such as `wit-component` and `wasm-compose` saw a few small
changes to continue compiling but do not have support added for resource
types. WIT, for example, continues to not support resource types. That's
planned to be added in a subsequent commit. This support is intended to
be everything necessary for Wasmtime to start working on implementing
resource types, and once that's ready I'll circle back to implement WIT
support with host/guest/etc generators.

This is a substantial commit. The binary format for resources is pretty
minor but the major feature it requires support for is the type-checking
in validation. Resources effectively add an ML-module-style type system
to the component model with abstract types. This required quite a lot of
meticulous and careful plumbing throughout the validator along with a
rewritten form of checking subtypes.

This commit in theory implements what should be all or at least a large
bulk of what's specified for resources at the binary format layer.
Without spec tests for formal spec wording it can't really be said how
close to the current documentation it follows, but the intention was to
follow it closely. Tests have been attempted to be added here in a
number of interesting flavors but this implementation is highly likely
to still have holes and/or bugs that break the guarantees of resources.

Co-authored-by: Trevor Elliott <telliott@fastly.com>

Author: alexcrichton

crates/wasm-compose/src/composer.rs

@@ -12,7 +12,7 @@ use anyhow::{anyhow, bail, Result};
 use indexmap::IndexMap;
 use std::{collections::VecDeque, path::Path};
 use wasmparser::{
-    types::{ComponentInstanceType, TypesRef},
+    types::{ComponentEntityType, TypeId, TypesRef},
     ComponentExternalKind, ComponentTypeRef,
 };
 
@@ -161,7 +161,7 @@ impl<'a> CompositionGraphBuilder<'a> {
         instance: usize,
         dependent: usize,
         arg_name: &str,
-        ty: &ComponentInstanceType,
+        ty: TypeId,
         types: TypesRef,
     ) -> Result<Option<ExportIndex>> {
         let (instance_name, instance_id) = self.instances.get_index(instance).unwrap();
@@ -204,15 +204,20 @@ impl<'a> CompositionGraphBuilder<'a> {
         instance: usize,
         dependent_path: &Path,
         arg_name: &str,
-        ty: &ComponentInstanceType,
+        ty: TypeId,
         types: TypesRef,
     ) -> Result<ExportIndex> {
         let (_, instance_id) = self.instances.get_index(instance).unwrap();
         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();
-                if !ComponentInstanceType::is_subtype_of(export_ty, component.types(), ty, types) {
+                if !ComponentEntityType::is_subtype_of(
+                    &ComponentEntityType::Instance(export_ty),
+                    component.types(),
+                    &ComponentEntityType::Instance(ty),
+                    types,
+                ) {
                     bail!("component `{path}` exports an instance named `{export}` but it is not compatible with import `{arg_name}` of component `{dependent_path}`",
                             path = component.path().unwrap().display(),
                             dependent_path = dependent_path.display(),
@@ -229,22 +234,14 @@ impl<'a> CompositionGraphBuilder<'a> {
     }
 
     /// Resolves an import instance reference.
-    fn resolve_import_ref(
-        &self,
-        r: InstanceImportRef,
-    ) -> (&Component, &str, &ComponentInstanceType) {
+    fn resolve_import_ref(&self, r: InstanceImportRef) -> (&Component, &str, TypeId) {
         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
-                    .type_at(index, false)
-                    .unwrap()
-                    .as_component_instance_type()
-                    .unwrap(),
+                component.types.id_from_type_index(index, false).unwrap(),
             ),
             _ => unreachable!("should not have an instance import ref to a non-instance import"),
         }

crates/wasm-compose/src/encoding.rs

@@ -251,7 +251,7 @@ impl<'a> TypeEncoder<'a> {
                 ComponentTypeRef::Value(self.component_val_type(encodable, types, ty))
             }
             wasmparser::types::ComponentEntityType::Type { created, .. } => {
-                ComponentTypeRef::Type(TypeBounds::Eq, self.ty(encodable, types, created))
+                ComponentTypeRef::Type(TypeBounds::Eq(self.ty(encodable, types, created)))
             }
             wasmparser::types::ComponentEntityType::Instance(id) => {
                 ComponentTypeRef::Instance(self.component_instance_type(encodable, types, id))
@@ -363,8 +363,8 @@ impl<'a> TypeEncoder<'a> {
             Entry::Occupied(e) => *e.get(),
             Entry::Vacant(e) => {
                 let ty = ty.as_component_instance_type().unwrap();
-                let instance = self.instance(ty.exports(self.0.as_ref()).map(|(n, u, t)| {
-                    (n.as_str(), u.as_ref().map(|u| u.as_str()).unwrap_or(""), t)
+                let instance = self.instance(ty.exports.iter().map(|(n, (u, t))| {
+                    (n.as_str(), u.as_ref().map(|u| u.as_str()).unwrap_or(""), *t)
                 }));
                 let index = encodable.type_count();
                 encodable.ty().instance(&instance);
@@ -471,6 +471,7 @@ impl<'a> TypeEncoder<'a> {
                 self.component_func_type(encodable, types, id)
             }
             wasmparser::types::Type::Defined(_) => self.defined_type(encodable, types, id),
+            wasmparser::types::Type::Resource(_) => unimplemented!(),
         }
     }
 
@@ -529,6 +530,18 @@ impl<'a> TypeEncoder<'a> {
             wasmparser::types::ComponentDefinedType::Result { ok, err } => {
                 self.result(encodable, types, *ok, *err)
             }
+            wasmparser::types::ComponentDefinedType::Own(id) => {
+                let i = self.defined_type(encodable, types, *id);
+                let index = encodable.type_count();
+                encodable.ty().defined_type().own(i);
+                index
+            }
+            wasmparser::types::ComponentDefinedType::Borrow(id) => {
+                let i = self.defined_type(encodable, types, *id);
+                let index = encodable.type_count();
+                encodable.ty().defined_type().borrow(i);
+                index
+            }
         };
 
         types.insert(PtrKey(ty), index);
@@ -720,16 +733,17 @@ impl ArgumentImport<'_> {
                 .unwrap()
                 .as_component_instance_type()
                 .unwrap()
-                .exports(component.types.as_ref());
+                .exports
+                .iter();
 
             let mut map = IndexMap::with_capacity(exports.len());
-            for (name, url, ty) in exports {
+            for (name, (url, ty)) in exports {
                 map.insert(
                     name.as_ref(),
                     (
                         url.as_ref().map(|u| u.as_str()).unwrap_or(""),
                         *component,
-                        ty,
+                        *ty,
                     ),
                 );
             }
@@ -756,13 +770,14 @@ impl ArgumentImport<'_> {
                     );
                 }
 
-                for (name, url, new_type) in new_component
+                for (name, (url, new_type)) in new_component
                     .types
                     .type_from_id(id)
                     .unwrap()
                     .as_component_instance_type()
                     .unwrap()
-                    .exports(new_component.types.as_ref())
+                    .exports
+                    .iter()
                 {
                     match exports.entry(name) {
                         indexmap::map::Entry::Occupied(mut e) => {
@@ -771,7 +786,7 @@ impl ArgumentImport<'_> {
                                 existing_component,
                                 *existing_type,
                                 new_component,
-                                new_type,
+                                *new_type,
                             ) {
                                 Some((c, ty)) => {
                                     *existing_component = c;
@@ -789,7 +804,7 @@ impl ArgumentImport<'_> {
                             e.insert((
                                 url.as_ref().map(|u| u.as_str()).unwrap_or(""),
                                 new_component,
-                                new_type,
+                                *new_type,
                             ));
                         }
                     }
@@ -1385,7 +1400,7 @@ impl<'a> CompositionGraphEncoder<'a> {
             ComponentTypeRef::Module(_) => ("module", &mut self.modules),
             ComponentTypeRef::Func(_) => ("function", &mut self.funcs),
             ComponentTypeRef::Value(_) => ("value", &mut self.values),
-            ComponentTypeRef::Type(_, _) => ("type", &mut self.types),
+            ComponentTypeRef::Type(_) => ("type", &mut self.types),
             ComponentTypeRef::Instance(_) => ("instance", &mut self.instances),
             ComponentTypeRef::Component(_) => ("component", &mut self.components),
         };

crates/wasm-compose/src/graph.rs

@@ -10,7 +10,7 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
 };
 use wasmparser::{
-    types::{ComponentEntityType, ComponentInstanceType, Types, TypesRef},
+    types::{ComponentEntityType, TypeId, Types, TypesRef},
     Chunk, ComponentExternalKind, ComponentTypeRef, Encoding, Parser, Payload, ValidPayload,
     Validator, WasmFeatures,
 };
@@ -277,7 +277,7 @@ impl<'a> Component<'a> {
     /// Finds a compatible instance export on the component for the given instance type.
     pub(crate) fn find_compatible_export(
         &self,
-        ty: &ComponentInstanceType,
+        ty: TypeId,
         types: TypesRef,
     ) -> Option<ExportIndex> {
         self.exports
@@ -286,10 +286,12 @@ impl<'a> Component<'a> {
                 if *kind != ComponentExternalKind::Instance {
                     return false;
                 }
-                ComponentInstanceType::is_subtype_of(
-                    self.types.component_instance_at(*index).unwrap(),
+                ComponentEntityType::is_subtype_of(
+                    &ComponentEntityType::Instance(
+                        self.types.component_instance_at(*index).unwrap(),
+                    ),
                     self.types.as_ref(),
-                    ty,
+                    &ComponentEntityType::Instance(ty),
                     types,
                 )
             })
@@ -298,18 +300,20 @@ 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: &ComponentInstanceType,
-        types: TypesRef,
-    ) -> bool {
-        let exports = ty.exports(types);
+    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();
 
-        for (k, _, b) in exports {
+        for (k, (_, b)) in exports {
             match self.exports.get_full(k.as_str()) {
                 Some((ai, _, _)) => {
                     let (_, _, a) = self.export_entity_type(ExportIndex(ai)).unwrap();
-                    if !ComponentEntityType::is_subtype_of(&a, self.types.as_ref(), &b, types) {
+                    if !ComponentEntityType::is_subtype_of(&a, self.types.as_ref(), b, types) {
                         return false;
                     }
                 }
@@ -761,12 +765,7 @@ impl<'a> CompositionGraph<'a> {
             }
         } else {
             let ty = match import_ty {
-                ComponentEntityType::Instance(id) => target_component
-                    .types
-                    .type_from_id(id)
-                    .unwrap()
-                    .as_component_instance_type()
-                    .unwrap(),
+                ComponentEntityType::Instance(id) => id,
                 _ => bail!(
                     "source instance is not compatible with target {import_ty} import `{import_name}`",
                     import_ty = type_desc(import_ty)
@@ -1262,7 +1261,7 @@ mod test {
   )
   (import "i4" (core module (;0;) (type 0)))
   (type (;3;) (tuple u32 u32))
-  (import "i5" (type (eq 3)))
+  (import "i5" (type (;4;) (eq 3)))
   (component (;1;)
     (type (;0;) (tuple u32 u32))
     (type (;1;)
@@ -1284,7 +1283,7 @@ mod test {
       (module)
     )
     (import "i4" (core module (;0;) (type 0)))
-    (import "i5" (type (eq 0)))
+    (import "i5" (type (;4;) (eq 0)))
     (export (;1;) "e1" (instance 0))
     (export (;1;) "e2" (func 0))
     (export (;1;) "e3" (component 0))
@@ -1312,7 +1311,7 @@ mod test {
       (module)
     )
     (import "i4" (core module (;0;) (type 0)))
-    (import "i5" (type (eq 0)))
+    (import "i5" (type (;4;) (eq 0)))
   )
   (instance (;1;) (instantiate 1
       (with "i1" (instance 0))

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

@@ -1,4 +1,4 @@
-use crate::{encode_section, ComponentSection, ComponentSectionId, Encode};
+use crate::{encode_section, ComponentSection, ComponentSectionId, ComponentValType, Encode};
 
 /// Represents options for canonical function definitions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -118,6 +118,32 @@ impl CanonicalFunctionSection {
         self.num_added += 1;
         self
     }
+
+    /// Defines a function which will create an owned handle to the resource
+    /// specified by `ty_index`.
+    pub fn resource_new(&mut self, ty_index: u32) -> &mut Self {
+        self.bytes.push(0x02);
+        ty_index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Defines a function which will drop the specified type of handle.
+    pub fn resource_drop(&mut self, ty: ComponentValType) -> &mut Self {
+        self.bytes.push(0x03);
+        ty.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Defines a function which will return the representation of the specified
+    /// resource type.
+    pub fn resource_rep(&mut self, ty_index: u32) -> &mut Self {
+        self.bytes.push(0x04);
+        ty_index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
 }
 
 impl Encode for CanonicalFunctionSection {

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

@@ -6,14 +6,20 @@ use crate::{
 /// Represents the possible type bounds for type references.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub enum TypeBounds {
-    /// The type is bounded by equality.
-    Eq,
+    /// The type is bounded by equality to the type index specified.
+    Eq(u32),
+    /// This type is a fresh resource type,
+    SubResource,
 }
 
 impl Encode for TypeBounds {
     fn encode(&self, sink: &mut Vec<u8>) {
         match self {
-            Self::Eq => sink.push(0x00),
+            Self::Eq(i) => {
+                sink.push(0x00);
+                i.encode(sink);
+            }
+            Self::SubResource => sink.push(0x01),
         }
     }
 }
@@ -32,9 +38,7 @@ pub enum ComponentTypeRef {
     /// The reference is to a value type.
     Value(ComponentValType),
     /// The reference is to a bounded type.
-    ///
-    /// The index is expected to be a type index.
-    Type(TypeBounds, u32),
+    Type(TypeBounds),
     /// The reference is to an instance type.
     ///
     /// The index is expected to be a type index to an instance type.
@@ -68,10 +72,7 @@ impl Encode for ComponentTypeRef {
                 idx.encode(sink);
             }
             Self::Value(ty) => ty.encode(sink),
-            Self::Type(bounds, idx) => {
-                bounds.encode(sink);
-                idx.encode(sink);
-            }
+            Self::Type(bounds) => bounds.encode(sink),
         }
     }
 }