Remove support for handles and resources (#346)

* Remove support for handles and resources

This commit removes all support for the `resource` and `Handle` types
from the AST of `wit-parser` and all related support in all code
generators. The motivation for this commit is that `wit-bindgen` is on
the cusp of actually being able to work with components: producing a
component from guest output and consuming components in host generators.
More detail about this is in #314. With components as an intermediate
format, however, there is no way to encode resources since they are not
part of the component model proposal yet.

All is not lost for handles and resources, though. The official design
for handles and resources is being worked on upstream in the component
model repository itself at this time and once added all of this support
will be re-added to `wit-bindgen`. In the meantime though I personally
think that the best way forward is to remove the interim support for a
few reasons:

* Primarily it unblocks progress at this time towards fully integrating
  components and the `wit-bindgen` generators. The requirement to run
  existing tests that use handles would mean that no host generator
  could actually switch to components and/or modes for today's
  core-wasm-lookalike would need to be preserved.

* Otherwise though the semantics of the current handles are basically
  invented out of thin air by myself and were never really formally
  specified, debated, or designed deliberately. I grafted `witx`-style
  handles into `wit-component` and added features as necessary over
  time, but it seems highly unlikely that the handles designed as part
  of the component model will be the ones that `wit-bindgen` currently
  supports. This inevitably means that a new system would need new code
  anyway and would likely result in removal regardless.

As usual git always has the history of handles and this all may come
back in one shape or another if only slightly tweaked. I'm confident in
our history spelunking abilities, though, so I don't feel that keeping
support in the repository is necessary for this purpose.

* Remove resources from the demo

* Fix rebase conflict

Author: alexcrichton

crates/bindgen-core/src/lib.rs

@@ -84,7 +84,6 @@ pub trait Generator {
     );
     fn type_union(&mut self, iface: &Interface, id: TypeId, name: &str, union: &Union, docs: &Docs);
     fn type_enum(&mut self, iface: &Interface, id: TypeId, name: &str, enum_: &Enum, docs: &Docs);
-    fn type_resource(&mut self, iface: &Interface, ty: ResourceId);
     fn type_alias(&mut self, iface: &Interface, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_list(&mut self, iface: &Interface, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_builtin(&mut self, iface: &Interface, id: TypeId, name: &str, ty: &Type, docs: &Docs);
@@ -131,10 +130,6 @@ pub trait Generator {
             }
         }
 
-        for (id, _resource) in iface.resources.iter() {
-            self.type_resource(iface, id);
-        }
-
         self.preprocess_functions(iface, dir);
 
         for f in iface.functions.iter() {
@@ -181,17 +176,13 @@ pub struct TypeInfo {
 
     /// Whether or not this type (transitively) has a list.
     pub has_list: bool,
-
-    /// Whether or not this type (transitively) has a handle.
-    pub has_handle: bool,
 }
 
 impl std::ops::BitOrAssign for TypeInfo {
     fn bitor_assign(&mut self, rhs: Self) {
         self.param |= rhs.param;
         self.result |= rhs.result;
         self.has_list |= rhs.has_list;
-        self.has_handle |= rhs.has_handle;
     }
 }
 
@@ -271,7 +262,6 @@ impl Types {
     pub fn type_info(&mut self, iface: &Interface, ty: &Type) -> TypeInfo {
         let mut info = TypeInfo::default();
         match ty {
-            Type::Handle(_) => info.has_handle = true,
             Type::String => info.has_list = true,
             Type::Id(id) => return self.type_id_info(iface, *id),
             _ => {}

crates/gen-guest-c/src/lib.rs

@@ -238,11 +238,6 @@ impl C {
             Type::S64 => self.src.h("int64_t"),
             Type::Float32 => self.src.h("float"),
             Type::Float64 => self.src.h("double"),
-            Type::Handle(id) => {
-                self.print_namespace(iface);
-                self.src.h(&iface.resources[*id].name.to_snake_case());
-                self.src.h("_t");
-            }
             Type::String => {
                 self.print_namespace(iface);
                 self.src.h("string_t");
@@ -285,7 +280,6 @@ impl C {
             Type::S64 => self.src.h("s64"),
             Type::Float32 => self.src.h("float32"),
             Type::Float64 => self.src.h("float64"),
-            Type::Handle(id) => self.src.h(&iface.resources[*id].name.to_snake_case()),
             Type::String => self.src.h("string"),
             Type::Id(id) => {
                 let ty = &iface.types[*id];
@@ -579,7 +573,6 @@ impl C {
         let id = match ty {
             Type::Id(id) => *id,
             Type::String => return true,
-            Type::Handle(_) => return true,
             _ => return false,
         };
         match &iface.types[id].kind {
@@ -945,10 +938,6 @@ impl Generator for C {
         self.types.insert(id, mem::replace(&mut self.src.h, prev));
     }
 
-    fn type_resource(&mut self, iface: &Interface, ty: ResourceId) {
-        drop((iface, ty));
-    }
-
     fn type_alias(&mut self, iface: &Interface, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
         let prev = mem::take(&mut self.src.h);
         self.docs(docs);
@@ -1178,90 +1167,6 @@ impl Generator for C {
 
         self.print_intrinsics();
 
-        for (_, resource) in iface.resources.iter() {
-            let ns = iface.name.to_snake_case();
-            let name = resource.name.to_snake_case();
-            uwrite!(
-                self.src.h,
-                "
-                    typedef struct {{
-                        uint32_t idx;
-                    }} {ns}_{name}_t;
-                    void {ns}_{name}_free({ns}_{name}_t *ptr);
-                    {ns}_{name}_t {ns}_{name}_clone({ns}_{name}_t *ptr);
-                ",
-                ns = ns,
-                name = name,
-            );
-            uwrite!(
-                self.src.c,
-                "
-                    __attribute__((import_module(\"canonical_abi\"), import_name(\"resource_drop_{name_orig}\")))
-                    void __resource_{name}_drop(uint32_t idx);
-
-                    void {ns}_{name}_free({ns}_{name}_t *ptr) {{
-                        __resource_{name}_drop(ptr->idx);
-                    }}
-
-                    __attribute__((import_module(\"canonical_abi\"), import_name(\"resource_clone_{name_orig}\")))
-                    uint32_t __resource_{name}_clone(uint32_t idx);
-
-                    {ns}_{name}_t {ns}_{name}_clone({ns}_{name}_t *ptr) {{
-                        return ({ns}_{name}_t){{__resource_{name}_clone(ptr->idx)}};
-                    }}
-                ",
-                ns = ns,
-                name = name,
-                name_orig = resource.name,
-            );
-
-            // Exported resources have more capabilities, they can create new
-            // resources and get the private value that it was created with.
-            // Furthermore we also define the destructor which delegates to the
-            // actual user-defined destructor, if any.
-            if !self.in_import {
-                uwrite!(
-                    self.src.h,
-                    "\
-                        {ns}_{name}_t {ns}_{name}_new(void *data);
-                        void* {ns}_{name}_get({ns}_{name}_t *ptr);
-
-                        __attribute__((weak))
-                        void {ns}_{name}_dtor(void *data);
-                    ",
-                    ns = ns,
-                    name = name,
-                );
-                uwrite!(
-                    self.src.c,
-                    "
-                        __attribute__((import_module(\"canonical_abi\"), import_name(\"resource_new_{name_orig}\")))
-                        uint32_t __resource_{name}_new(uint32_t val);
-
-                        {ns}_{name}_t {ns}_{name}_new(void *data) {{
-                            return ({ns}_{name}_t){{__resource_{name}_new((uint32_t) data)}};
-                        }}
-
-                        __attribute__((import_module(\"canonical_abi\"), import_name(\"resource_get_{name_orig}\")))
-                        uint32_t __resource_{name}_get(uint32_t idx);
-
-                        void* {ns}_{name}_get({ns}_{name}_t *ptr) {{
-                            return (void*) __resource_{name}_get(ptr->idx);
-                        }}
-
-                        __attribute__((export_name(\"canonical_abi_drop_{name_orig}\")))
-                        void __resource_{name}_dtor(uint32_t val) {{
-                            if ({ns}_{name}_dtor)
-                                {ns}_{name}_dtor((void*) val);
-                        }}
-                    ",
-                    ns = ns,
-                    name = name,
-                    name_orig = resource.name,
-                );
-            }
-        }
-
         // Continuously generate anonymous types while we continue to find more
         //
         // First we take care of the public set of anonymous types. This will
@@ -1595,20 +1500,6 @@ impl Bindgen for FunctionBindgen<'_> {
                 results.push(operands[0].clone());
             }
 
-            Instruction::I32FromOwnedHandle { .. } | Instruction::I32FromBorrowedHandle { .. } => {
-                results.push(format!("({}).idx", operands[0]));
-            }
-
-            Instruction::HandleBorrowedFromI32 { ty, .. }
-            | Instruction::HandleOwnedFromI32 { ty, .. } => {
-                results.push(format!(
-                    "({}_{}_t){{ {} }}",
-                    iface.name.to_snake_case(),
-                    iface.resources[*ty].name.to_snake_case(),
-                    operands[0],
-                ));
-            }
-
             Instruction::RecordLower { record, .. } => {
                 let op = &operands[0];
                 for f in record.fields.iter() {