Canonical ABI name mangling (#309)

* Rename `canonical_abi_realloc` to `cabi_realloc`.

This follows the current Canonical ABI. This doesn't rename
`canonical_abi_free`, as that's expected to be removed when post-return
functions are implemented.

* Rename the "expected" type to "result".

This follows the current Canonical ABI.

* Implement function and value type name mangling.

This implements the name-mangling scheme in the current canonical ABI,
with the modification proposed in WebAssembly/component-model#104,
though that can be easily removed if the proposal is declined.

* Use name mangling in the bindings generators.

* Use the export base name rather than the mangled name for python identifiers.

Author: sunfishcode

TODO.md

@@ -25,7 +25,7 @@
 
 * Is there a better representation for flags than simply an integer?
 
-* Should functions returning `expected<T, E>` get translated in JS to functions
+* Should functions returning `result<T, E>` get translated in JS to functions
   that return `T` and throw `E`?
 
 * Adding imports to an import object is clunky because you need to also pass in

crates/bindgen-core/src/lib.rs

@@ -74,12 +74,12 @@ pub trait Generator {
         payload: &Type,
         docs: &Docs,
     );
-    fn type_expected(
+    fn type_result(
         &mut self,
         iface: &Interface,
         id: TypeId,
         name: &str,
-        expected: &Expected,
+        result: &Result_,
         docs: &Docs,
     );
     fn type_union(&mut self, iface: &Interface, id: TypeId, name: &str, union: &Union, docs: &Docs);
@@ -122,7 +122,7 @@ pub trait Generator {
                     self.type_variant(iface, id, name, variant, &ty.docs)
                 }
                 TypeDefKind::Option(t) => self.type_option(iface, id, name, t, &ty.docs),
-                TypeDefKind::Expected(e) => self.type_expected(iface, id, name, e, &ty.docs),
+                TypeDefKind::Result(r) => self.type_result(iface, id, name, r, &ty.docs),
                 TypeDefKind::Union(u) => self.type_union(iface, id, name, u, &ty.docs),
                 TypeDefKind::List(t) => self.type_list(iface, id, name, t, &ty.docs),
                 TypeDefKind::Type(t) => self.type_alias(iface, id, name, t, &ty.docs),
@@ -245,9 +245,9 @@ impl Types {
             TypeDefKind::Option(ty) => {
                 info = self.type_info(iface, ty);
             }
-            TypeDefKind::Expected(e) => {
-                info = self.type_info(iface, &e.ok);
-                info |= self.type_info(iface, &e.err);
+            TypeDefKind::Result(r) => {
+                info = self.type_info(iface, &r.ok);
+                info |= self.type_info(iface, &r.err);
             }
             TypeDefKind::Union(u) => {
                 for case in u.cases.iter() {
@@ -299,9 +299,9 @@ impl Types {
             TypeDefKind::List(ty) | TypeDefKind::Type(ty) | TypeDefKind::Option(ty) => {
                 self.set_param_result_ty(iface, ty, param, result)
             }
-            TypeDefKind::Expected(e) => {
-                self.set_param_result_ty(iface, &e.ok, param, result);
-                self.set_param_result_ty(iface, &e.err, param, result);
+            TypeDefKind::Result(r) => {
+                self.set_param_result_ty(iface, &r.ok, param, result);
+                self.set_param_result_ty(iface, &r.err, param, result);
             }
             TypeDefKind::Union(u) => {
                 for case in u.cases.iter() {