[wasm-c-api] Roll 8f25c3f: Get rid of massive overloading

Change-Id: I144217abfdcb16e4b9e90e5729fe0aa389945dfb
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1748691Reviewed-by: Andreas Haas <ahaas@chromium.org>
Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63162}

src/wasm/c-api.cc

@@ -2034,113 +2034,130 @@ struct borrowed_vec {
 
 }  // extern "C++"
 
-#define WASM_DEFINE_OWN(name, Name)                                          \
-  struct wasm_##name##_t : Name {};                                          \
-                                                                             \
-  void wasm_##name##_delete(wasm_##name##_t* x) { delete x; }                \
-                                                                             \
-  extern "C++" inline auto hide(Name* x)->wasm_##name##_t* {                 \
-    return static_cast<wasm_##name##_t*>(x);                                 \
-  }                                                                          \
-  extern "C++" inline auto hide(const Name* x)->const wasm_##name##_t* {     \
-    return static_cast<const wasm_##name##_t*>(x);                           \
-  }                                                                          \
-  extern "C++" inline auto reveal(wasm_##name##_t* x)->Name* { return x; }   \
-  extern "C++" inline auto reveal(const wasm_##name##_t* x)->const Name* {   \
-    return x;                                                                \
-  }                                                                          \
-  extern "C++" inline auto get(wasm::own<Name*>& x)->wasm_##name##_t* {      \
-    return hide(x.get());                                                    \
-  }                                                                          \
-  extern "C++" inline auto get(const wasm::own<Name*>& x)                    \
-      ->const wasm_##name##_t* {                                             \
-    return hide(x.get());                                                    \
-  }                                                                          \
-  extern "C++" inline auto release(wasm::own<Name*>&& x)->wasm_##name##_t* { \
-    return hide(x.release());                                                \
-  }                                                                          \
-  extern "C++" inline auto adopt(wasm_##name##_t* x)->wasm::own<Name*> {     \
-    return make_own(x);                                                      \
+#define WASM_DEFINE_OWN(name, Name)                                            \
+  struct wasm_##name##_t : Name {};                                            \
+                                                                               \
+  void wasm_##name##_delete(wasm_##name##_t* x) { delete x; }                  \
+                                                                               \
+  extern "C++" inline auto hide_##name(Name* x)->wasm_##name##_t* {            \
+    return static_cast<wasm_##name##_t*>(x);                                   \
+  }                                                                            \
+  extern "C++" inline auto hide_##name(const Name* x)                          \
+      ->const wasm_##name##_t* {                                               \
+    return static_cast<const wasm_##name##_t*>(x);                             \
+  }                                                                            \
+  extern "C++" inline auto reveal_##name(wasm_##name##_t* x)->Name* {          \
+    return x;                                                                  \
+  }                                                                            \
+  extern "C++" inline auto reveal_##name(const wasm_##name##_t* x)             \
+      ->const Name* {                                                          \
+    return x;                                                                  \
+  }                                                                            \
+  extern "C++" inline auto get_##name(wasm::own<Name*>& x)->wasm_##name##_t* { \
+    return hide_##name(x.get());                                               \
+  }                                                                            \
+  extern "C++" inline auto get_##name(const wasm::own<Name*>& x)               \
+      ->const wasm_##name##_t* {                                               \
+    return hide_##name(x.get());                                               \
+  }                                                                            \
+  extern "C++" inline auto release_##name(wasm::own<Name*>&& x)                \
+      ->wasm_##name##_t* {                                                     \
+    return hide_##name(x.release());                                           \
+  }                                                                            \
+  extern "C++" inline auto adopt_##name(wasm_##name##_t* x)                    \
+      ->wasm::own<Name*> {                                                     \
+    return make_own(x);                                                        \
   }
 
 // Vectors
 
-#define WASM_DEFINE_VEC_BASE(name, Name, ptr_or_none)                       \
-  extern "C++" inline auto hide(wasm::vec<Name ptr_or_none>& v)             \
-      ->wasm_##name##_vec_t* {                                              \
-    static_assert(sizeof(wasm_##name##_vec_t) == sizeof(wasm::vec<Name>),   \
-                  "C/C++ incompatibility");                                 \
-    return reinterpret_cast<wasm_##name##_vec_t*>(&v);                      \
-  }                                                                         \
-  extern "C++" inline auto hide(const wasm::vec<Name ptr_or_none>& v)       \
-      ->const wasm_##name##_vec_t* {                                        \
-    static_assert(sizeof(wasm_##name##_vec_t) == sizeof(wasm::vec<Name>),   \
-                  "C/C++ incompatibility");                                 \
-    return reinterpret_cast<const wasm_##name##_vec_t*>(&v);                \
-  }                                                                         \
-  extern "C++" inline auto hide(Name ptr_or_none* v)                        \
-      ->wasm_##name##_t ptr_or_none* {                                      \
-    static_assert(                                                          \
-        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),    \
-        "C/C++ incompatibility");                                           \
-    return reinterpret_cast<wasm_##name##_t ptr_or_none*>(v);               \
-  }                                                                         \
-  extern "C++" inline auto hide(Name ptr_or_none const* v)                  \
-      ->wasm_##name##_t ptr_or_none const* {                                \
-    static_assert(                                                          \
-        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),    \
-        "C/C++ incompatibility");                                           \
-    return reinterpret_cast<wasm_##name##_t ptr_or_none const*>(v);         \
-  }                                                                         \
-  extern "C++" inline auto reveal(wasm_##name##_t ptr_or_none* v)           \
-      ->Name ptr_or_none* {                                                 \
-    static_assert(                                                          \
-        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),    \
-        "C/C++ incompatibility");                                           \
-    return reinterpret_cast<Name ptr_or_none*>(v);                          \
-  }                                                                         \
-  extern "C++" inline auto reveal(wasm_##name##_t ptr_or_none const* v)     \
-      ->Name ptr_or_none const* {                                           \
-    static_assert(                                                          \
-        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),    \
-        "C/C++ incompatibility");                                           \
-    return reinterpret_cast<Name ptr_or_none const*>(v);                    \
-  }                                                                         \
-  extern "C++" inline auto get(wasm::vec<Name ptr_or_none>& v)              \
-      ->wasm_##name##_vec_t {                                               \
-    wasm_##name##_vec_t v2 = {v.size(), hide(v.get())};                     \
-    return v2;                                                              \
-  }                                                                         \
-  extern "C++" inline auto get(const wasm::vec<Name ptr_or_none>& v)        \
-      ->const wasm_##name##_vec_t {                                         \
-    wasm_##name##_vec_t v2 = {                                              \
-        v.size(), const_cast<wasm_##name##_t ptr_or_none*>(hide(v.get()))}; \
-    return v2;                                                              \
-  }                                                                         \
-  extern "C++" inline auto release(wasm::vec<Name ptr_or_none>&& v)         \
-      ->wasm_##name##_vec_t {                                               \
-    wasm_##name##_vec_t v2 = {v.size(), hide(v.release())};                 \
-    return v2;                                                              \
-  }                                                                         \
-  extern "C++" inline auto adopt(wasm_##name##_vec_t* v)                    \
-      ->wasm::vec<Name ptr_or_none> {                                       \
-    return wasm::vec<Name ptr_or_none>::adopt(v->size, reveal(v->data));    \
-  }                                                                         \
-  extern "C++" inline auto borrow(const wasm_##name##_vec_t* v)             \
-      ->borrowed_vec<Name ptr_or_none> {                                    \
-    return borrowed_vec<Name ptr_or_none>(                                  \
-        wasm::vec<Name ptr_or_none>::adopt(v->size, reveal(v->data)));      \
-  }                                                                         \
-                                                                            \
-  void wasm_##name##_vec_new_uninitialized(wasm_##name##_vec_t* out,        \
-                                           size_t size) {                   \
-    *out = release(wasm::vec<Name ptr_or_none>::make_uninitialized(size));  \
-  }                                                                         \
-  void wasm_##name##_vec_new_empty(wasm_##name##_vec_t* out) {              \
-    wasm_##name##_vec_new_uninitialized(out, 0);                            \
-  }                                                                         \
-                                                                            \
-  void wasm_##name##_vec_delete(wasm_##name##_vec_t* v) { adopt(v); }
+#define WASM_DEFINE_VEC_BASE(name, Name, ptr_or_none)                          \
+  extern "C++" inline auto hide_##name##_vec(wasm::vec<Name ptr_or_none>& v)   \
+      ->wasm_##name##_vec_t* {                                                 \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_vec_t) == sizeof(wasm::vec<Name ptr_or_none>),    \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<wasm_##name##_vec_t*>(&v);                         \
+  }                                                                            \
+  extern "C++" inline auto hide_##name##_vec(                                  \
+      const wasm::vec<Name ptr_or_none>& v)                                    \
+      ->const wasm_##name##_vec_t* {                                           \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_vec_t) == sizeof(wasm::vec<Name ptr_or_none>),    \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<const wasm_##name##_vec_t*>(&v);                   \
+  }                                                                            \
+  extern "C++" inline auto hide_##name##_vec(Name ptr_or_none* v)              \
+      ->wasm_##name##_t ptr_or_none* {                                         \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),       \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<wasm_##name##_t ptr_or_none*>(v);                  \
+  }                                                                            \
+  extern "C++" inline auto hide_##name##_vec(Name ptr_or_none const* v)        \
+      ->wasm_##name##_t ptr_or_none const* {                                   \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),       \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<wasm_##name##_t ptr_or_none const*>(v);            \
+  }                                                                            \
+  extern "C++" inline auto reveal_##name##_vec(wasm_##name##_t ptr_or_none* v) \
+      ->Name ptr_or_none* {                                                    \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),       \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<Name ptr_or_none*>(v);                             \
+  }                                                                            \
+  extern "C++" inline auto reveal_##name##_vec(                                \
+      wasm_##name##_t ptr_or_none const* v)                                    \
+      ->Name ptr_or_none const* {                                              \
+    static_assert(                                                             \
+        sizeof(wasm_##name##_t ptr_or_none) == sizeof(Name ptr_or_none),       \
+        "C/C++ incompatibility");                                              \
+    return reinterpret_cast<Name ptr_or_none const*>(v);                       \
+  }                                                                            \
+  extern "C++" inline auto get_##name##_vec(wasm::vec<Name ptr_or_none>& v)    \
+      ->wasm_##name##_vec_t {                                                  \
+    wasm_##name##_vec_t v2 = {v.size(), hide_##name##_vec(v.get())};           \
+    return v2;                                                                 \
+  }                                                                            \
+  extern "C++" inline auto get_##name##_vec(                                   \
+      const wasm::vec<Name ptr_or_none>& v)                                    \
+      ->const wasm_##name##_vec_t {                                            \
+    wasm_##name##_vec_t v2 = {                                                 \
+        v.size(),                                                              \
+        const_cast<wasm_##name##_t ptr_or_none*>(hide_##name##_vec(v.get()))}; \
+    return v2;                                                                 \
+  }                                                                            \
+  extern "C++" inline auto release_##name##_vec(                               \
+      wasm::vec<Name ptr_or_none>&& v)                                         \
+      ->wasm_##name##_vec_t {                                                  \
+    wasm_##name##_vec_t v2 = {v.size(), hide_##name##_vec(v.release())};       \
+    return v2;                                                                 \
+  }                                                                            \
+  extern "C++" inline auto adopt_##name##_vec(wasm_##name##_vec_t* v)          \
+      ->wasm::vec<Name ptr_or_none> {                                          \
+    return wasm::vec<Name ptr_or_none>::adopt(v->size,                         \
+                                              reveal_##name##_vec(v->data));   \
+  }                                                                            \
+  extern "C++" inline auto borrow_##name##_vec(const wasm_##name##_vec_t* v)   \
+      ->borrowed_vec<Name ptr_or_none> {                                       \
+    return borrowed_vec<Name ptr_or_none>(wasm::vec<Name ptr_or_none>::adopt(  \
+        v->size, reveal_##name##_vec(v->data)));                               \
+  }                                                                            \
+                                                                               \
+  void wasm_##name##_vec_new_uninitialized(wasm_##name##_vec_t* out,           \
+                                           size_t size) {                      \
+    *out = release_##name##_vec(                                               \
+        wasm::vec<Name ptr_or_none>::make_uninitialized(size));                \
+  }                                                                            \
+  void wasm_##name##_vec_new_empty(wasm_##name##_vec_t* out) {                 \
+    wasm_##name##_vec_new_uninitialized(out, 0);                               \
+  }                                                                            \
+                                                                               \
+  void wasm_##name##_vec_delete(wasm_##name##_vec_t* v) {                      \
+    adopt_##name##_vec(v);                                                     \
+  }
 
 // Vectors with no ownership management of elements
 #define WASM_DEFINE_VEC_PLAIN(name, Name, ptr_or_none)                    \
@@ -2152,7 +2169,7 @@ struct borrowed_vec {
     if (v2.size() != 0) {                                                 \
       memcpy(v2.get(), data, size * sizeof(wasm_##name##_t ptr_or_none)); \
     }                                                                     \
-    *out = release(std::move(v2));                                        \
+    *out = release_##name##_vec(std::move(v2));                           \
   }                                                                       \
                                                                           \
   void wasm_##name##_vec_copy(wasm_##name##_vec_t* out,                   \
@@ -2160,7 +2177,7 @@ struct borrowed_vec {
     wasm_##name##_vec_new(out, v->size, v->data);                         \
   }
 
-// Vectors who own their elements
+// Vectors that own their elements
 #define WASM_DEFINE_VEC(name, Name, ptr_or_none)                         \
   WASM_DEFINE_VEC_BASE(name, Name, ptr_or_none)                          \
                                                                          \
@@ -2168,18 +2185,18 @@ struct borrowed_vec {
                              wasm_##name##_t ptr_or_none const data[]) { \
     auto v2 = wasm::vec<Name ptr_or_none>::make_uninitialized(size);     \
     for (size_t i = 0; i < v2.size(); ++i) {                             \
-      v2[i] = adopt(data[i]);                                            \
+      v2[i] = adopt_##name(data[i]);                                     \
     }                                                                    \
-    *out = release(std::move(v2));                                       \
+    *out = release_##name##_vec(std::move(v2));                          \
   }                                                                      \
                                                                          \
   void wasm_##name##_vec_copy(wasm_##name##_vec_t* out,                  \
                               wasm_##name##_vec_t* v) {                  \
     auto v2 = wasm::vec<Name ptr_or_none>::make_uninitialized(v->size);  \
     for (size_t i = 0; i < v2.size(); ++i) {                             \
-      v2[i] = adopt(wasm_##name##_copy(v->data[i]));                     \
+      v2[i] = adopt_##name(wasm_##name##_copy(v->data[i]));              \
     }                                                                    \
-    *out = release(std::move(v2));                                       \
+    *out = release_##name##_vec(std::move(v2));                          \
   }
 
 extern "C++" {
@@ -2201,16 +2218,20 @@ WASM_DEFINE_VEC_PLAIN(byte, byte, )
 
 WASM_DEFINE_OWN(config, wasm::Config)
 
-wasm_config_t* wasm_config_new() { return release(wasm::Config::make()); }
+wasm_config_t* wasm_config_new() {
+  return release_config(wasm::Config::make());
+}
 
 // Engine
 
 WASM_DEFINE_OWN(engine, wasm::Engine)
 
-wasm_engine_t* wasm_engine_new() { return release(wasm::Engine::make()); }
+wasm_engine_t* wasm_engine_new() {
+  return release_engine(wasm::Engine::make());
+}
 
 wasm_engine_t* wasm_engine_new_with_config(wasm_config_t* config) {
-  return release(wasm::Engine::make(adopt(config)));
+  return release_engine(wasm::Engine::make(adopt_config(config)));
 }
 
 // Stores
@@ -2218,7 +2239,7 @@ wasm_engine_t* wasm_engine_new_with_config(wasm_config_t* config) {
 WASM_DEFINE_OWN(store, wasm::Store)
 
 wasm_store_t* wasm_store_new(wasm_engine_t* engine) {
-  return release(wasm::Store::make(engine));
+  return release_store(wasm::Store::make(engine));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2226,38 +2247,40 @@ wasm_store_t* wasm_store_new(wasm_engine_t* engine) {
 
 // Type attributes
 
-extern "C++" inline auto hide(wasm::Mutability mutability)
+extern "C++" inline auto hide_mutability(wasm::Mutability mutability)
     -> wasm_mutability_t {
   return static_cast<wasm_mutability_t>(mutability);
 }
 
-extern "C++" inline auto reveal(wasm_mutability_enum mutability)
+extern "C++" inline auto reveal_mutability(wasm_mutability_enum mutability)
     -> wasm::Mutability {
   return static_cast<wasm::Mutability>(mutability);
 }
 
-extern "C++" inline auto hide(const wasm::Limits& limits)
+extern "C++" inline auto hide_limits(const wasm::Limits& limits)
     -> const wasm_limits_t* {
   return reinterpret_cast<const wasm_limits_t*>(&limits);
 }
 
-extern "C++" inline auto reveal(wasm_limits_t limits) -> wasm::Limits {
+extern "C++" inline auto reveal_limits(wasm_limits_t limits) -> wasm::Limits {
   return wasm::Limits(limits.min, limits.max);
 }
 
-extern "C++" inline auto hide(wasm::ValKind kind) -> wasm_valkind_t {
+extern "C++" inline auto hide_valkind(wasm::ValKind kind) -> wasm_valkind_t {
   return static_cast<wasm_valkind_t>(kind);
 }
 
-extern "C++" inline auto reveal(wasm_valkind_enum kind) -> wasm::ValKind {
+extern "C++" inline auto reveal_valkind(wasm_valkind_t kind) -> wasm::ValKind {
   return static_cast<wasm::ValKind>(kind);
 }
 
-extern "C++" inline auto hide(wasm::ExternKind kind) -> wasm_externkind_t {
+extern "C++" inline auto hide_externkind(wasm::ExternKind kind)
+    -> wasm_externkind_t {
   return static_cast<wasm_externkind_t>(kind);
 }
 
-extern "C++" inline auto reveal(wasm_externkind_enum kind) -> wasm::ExternKind {
+extern "C++" inline auto reveal_externkind(wasm_externkind_enum kind)
+    -> wasm::ExternKind {
   return static_cast<wasm::ExternKind>(kind);
 }
 
@@ -2268,7 +2291,7 @@ extern "C++" inline auto reveal(wasm_externkind_enum kind) -> wasm::ExternKind {
   WASM_DEFINE_VEC(name, Name, *)                            \
                                                             \
   wasm_##name##_t* wasm_##name##_copy(wasm_##name##_t* t) { \
-    return release(t->copy());                              \
+    return release_##name(t->copy());                       \
   }
 
 // Value Types
@@ -2276,12 +2299,11 @@ extern "C++" inline auto reveal(wasm_externkind_enum kind) -> wasm::ExternKind {
 WASM_DEFINE_TYPE(valtype, wasm::ValType)
 
 wasm_valtype_t* wasm_valtype_new(wasm_valkind_t k) {
-  return release(
-      wasm::ValType::make(reveal(static_cast<wasm_valkind_enum>(k))));
+  return release_valtype(wasm::ValType::make(reveal_valkind(k)));
 }
 
 wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t* t) {
-  return hide(t->kind());
+  return hide_valkind(t->kind());
 }
 
 // Function Types
@@ -2290,15 +2312,16 @@ WASM_DEFINE_TYPE(functype, wasm::FuncType)
 
 wasm_functype_t* wasm_functype_new(wasm_valtype_vec_t* params,
                                    wasm_valtype_vec_t* results) {
-  return release(wasm::FuncType::make(adopt(params), adopt(results)));
+  return release_functype(wasm::FuncType::make(adopt_valtype_vec(params),
+                                               adopt_valtype_vec(results)));
 }
 
 const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t* ft) {
-  return hide(ft->params());
+  return hide_valtype_vec(ft->params());
 }
 
 const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t* ft) {
-  return hide(ft->results());
+  return hide_valtype_vec(ft->results());
 }
 
 // Global Types
@@ -2307,16 +2330,17 @@ WASM_DEFINE_TYPE(globaltype, wasm::GlobalType)
 
 wasm_globaltype_t* wasm_globaltype_new(wasm_valtype_t* content,
                                        wasm_mutability_t mutability) {
-  return release(wasm::GlobalType::make(
-      adopt(content), reveal(static_cast<wasm_mutability_enum>(mutability))));
+  return release_globaltype(wasm::GlobalType::make(
+      adopt_valtype(content),
+      reveal_mutability(static_cast<wasm_mutability_enum>(mutability))));
 }
 
 const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t* gt) {
-  return hide(gt->content());
+  return hide_valtype(gt->content());
 }
 
 wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t* gt) {
-  return hide(gt->mutability());
+  return hide_mutability(gt->mutability());
 }
 
 // Table Types
@@ -2325,15 +2349,16 @@ WASM_DEFINE_TYPE(tabletype, wasm::TableType)
 
 wasm_tabletype_t* wasm_tabletype_new(wasm_valtype_t* element,
                                      const wasm_limits_t* limits) {
-  return release(wasm::TableType::make(adopt(element), reveal(*limits)));
+  return release_tabletype(
+      wasm::TableType::make(adopt_valtype(element), reveal_limits(*limits)));
 }
 
 const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t* tt) {
-  return hide(tt->element());
+  return hide_valtype(tt->element());
 }
 
 const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t* tt) {
-  return hide(tt->limits());
+  return hide_limits(tt->limits());
 }
 
 // Memory Types
@@ -2341,11 +2366,11 @@ const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t* tt) {
 WASM_DEFINE_TYPE(memorytype, wasm::MemoryType)
 
 wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t* limits) {
-  return release(wasm::MemoryType::make(reveal(*limits)));
+  return release_memorytype(wasm::MemoryType::make(reveal_limits(*limits)));
 }
 
 const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t* mt) {
-  return hide(mt->limits());
+  return hide_limits(mt->limits());
 }
 
 // Extern Types
@@ -2353,82 +2378,90 @@ const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t* mt) {
 WASM_DEFINE_TYPE(externtype, wasm::ExternType)
 
 wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t* et) {
-  return hide(et->kind());
+  return hide_externkind(et->kind());
 }
 
 wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t* ft) {
-  return hide(static_cast<wasm::ExternType*>(ft));
+  return hide_externtype(static_cast<wasm::ExternType*>(ft));
 }
 wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t* gt) {
-  return hide(static_cast<wasm::ExternType*>(gt));
+  return hide_externtype(static_cast<wasm::ExternType*>(gt));
 }
 wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t* tt) {
-  return hide(static_cast<wasm::ExternType*>(tt));
+  return hide_externtype(static_cast<wasm::ExternType*>(tt));
 }
 wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t* mt) {
-  return hide(static_cast<wasm::ExternType*>(mt));
+  return hide_externtype(static_cast<wasm::ExternType*>(mt));
 }
 
 const wasm_externtype_t* wasm_functype_as_externtype_const(
     const wasm_functype_t* ft) {
-  return hide(static_cast<const wasm::ExternType*>(ft));
+  return hide_externtype(static_cast<const wasm::ExternType*>(ft));
 }
 const wasm_externtype_t* wasm_globaltype_as_externtype_const(
     const wasm_globaltype_t* gt) {
-  return hide(static_cast<const wasm::ExternType*>(gt));
+  return hide_externtype(static_cast<const wasm::ExternType*>(gt));
 }
 const wasm_externtype_t* wasm_tabletype_as_externtype_const(
     const wasm_tabletype_t* tt) {
-  return hide(static_cast<const wasm::ExternType*>(tt));
+  return hide_externtype(static_cast<const wasm::ExternType*>(tt));
 }
 const wasm_externtype_t* wasm_memorytype_as_externtype_const(
     const wasm_memorytype_t* mt) {
-  return hide(static_cast<const wasm::ExternType*>(mt));
+  return hide_externtype(static_cast<const wasm::ExternType*>(mt));
 }
 
 wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_FUNC
-             ? hide(static_cast<wasm::FuncType*>(reveal(et)))
+             ? hide_functype(
+                   static_cast<wasm::FuncType*>(reveal_externtype(et)))
              : nullptr;
 }
 wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_GLOBAL
-             ? hide(static_cast<wasm::GlobalType*>(reveal(et)))
+             ? hide_globaltype(
+                   static_cast<wasm::GlobalType*>(reveal_externtype(et)))
              : nullptr;
 }
 wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_TABLE
-             ? hide(static_cast<wasm::TableType*>(reveal(et)))
+             ? hide_tabletype(
+                   static_cast<wasm::TableType*>(reveal_externtype(et)))
              : nullptr;
 }
 wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_MEMORY
-             ? hide(static_cast<wasm::MemoryType*>(reveal(et)))
+             ? hide_memorytype(
+                   static_cast<wasm::MemoryType*>(reveal_externtype(et)))
              : nullptr;
 }
 
 const wasm_functype_t* wasm_externtype_as_functype_const(
     const wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_FUNC
-             ? hide(static_cast<const wasm::FuncType*>(reveal(et)))
+             ? hide_functype(
+                   static_cast<const wasm::FuncType*>(reveal_externtype(et)))
              : nullptr;
 }
 const wasm_globaltype_t* wasm_externtype_as_globaltype_const(
     const wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_GLOBAL
-             ? hide(static_cast<const wasm::GlobalType*>(reveal(et)))
+             ? hide_globaltype(
+                   static_cast<const wasm::GlobalType*>(reveal_externtype(et)))
              : nullptr;
 }
 const wasm_tabletype_t* wasm_externtype_as_tabletype_const(
     const wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_TABLE
-             ? hide(static_cast<const wasm::TableType*>(reveal(et)))
+             ? hide_tabletype(
+                   static_cast<const wasm::TableType*>(reveal_externtype(et)))
              : nullptr;
 }
 const wasm_memorytype_t* wasm_externtype_as_memorytype_const(
     const wasm_externtype_t* et) {
   return et->kind() == wasm::EXTERN_MEMORY
-             ? hide(static_cast<const wasm::MemoryType*>(reveal(et)))
+             ? hide_memorytype(
+                   static_cast<const wasm::MemoryType*>(reveal_externtype(et)))
              : nullptr;
 }
 
@@ -2438,20 +2471,20 @@ WASM_DEFINE_TYPE(importtype, wasm::ImportType)
 
 wasm_importtype_t* wasm_importtype_new(wasm_name_t* module, wasm_name_t* name,
                                        wasm_externtype_t* type) {
-  return release(
-      wasm::ImportType::make(adopt(module), adopt(name), adopt(type)));
+  return release_importtype(wasm::ImportType::make(
+      adopt_byte_vec(module), adopt_byte_vec(name), adopt_externtype(type)));
 }
 
 const wasm_name_t* wasm_importtype_module(const wasm_importtype_t* it) {
-  return hide(it->module());
+  return hide_byte_vec(it->module());
 }
 
 const wasm_name_t* wasm_importtype_name(const wasm_importtype_t* it) {
-  return hide(it->name());
+  return hide_byte_vec(it->name());
 }
 
 const wasm_externtype_t* wasm_importtype_type(const wasm_importtype_t* it) {
-  return hide(it->type());
+  return hide_externtype(it->type());
 }
 
 // Export Types
@@ -2460,15 +2493,16 @@ WASM_DEFINE_TYPE(exporttype, wasm::ExportType)
 
 wasm_exporttype_t* wasm_exporttype_new(wasm_name_t* name,
                                        wasm_externtype_t* type) {
-  return release(wasm::ExportType::make(adopt(name), adopt(type)));
+  return release_exporttype(
+      wasm::ExportType::make(adopt_byte_vec(name), adopt_externtype(type)));
 }
 
 const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t* et) {
-  return hide(et->name());
+  return hide_byte_vec(et->name());
 }
 
 const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t* et) {
-  return hide(et->type());
+  return hide_externtype(et->type());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2480,7 +2514,7 @@ const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t* et) {
   WASM_DEFINE_OWN(name, Name)                                        \
                                                                      \
   wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t* t) {    \
-    return release(t->copy());                                       \
+    return release_##name(t->copy());                                \
   }                                                                  \
                                                                      \
   bool wasm_##name##_same(const wasm_##name##_t* t1,                 \
@@ -2503,17 +2537,17 @@ const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t* et) {
   WASM_DEFINE_REF_BASE(name, Name)                                         \
                                                                            \
   wasm_ref_t* wasm_##name##_as_ref(wasm_##name##_t* r) {                   \
-    return hide(static_cast<wasm::Ref*>(reveal(r)));                       \
+    return hide_ref(static_cast<wasm::Ref*>(reveal_##name(r)));            \
   }                                                                        \
   wasm_##name##_t* wasm_ref_as_##name(wasm_ref_t* r) {                     \
-    return hide(static_cast<Name*>(reveal(r)));                            \
+    return hide_##name(static_cast<Name*>(reveal_ref(r)));                 \
   }                                                                        \
                                                                            \
   const wasm_ref_t* wasm_##name##_as_ref_const(const wasm_##name##_t* r) { \
-    return hide(static_cast<const wasm::Ref*>(reveal(r)));                 \
+    return hide_ref(static_cast<const wasm::Ref*>(reveal_##name(r)));      \
   }                                                                        \
   const wasm_##name##_t* wasm_ref_as_##name##_const(const wasm_ref_t* r) { \
-    return hide(static_cast<const Name*>(reveal(r)));                      \
+    return hide_##name(static_cast<const Name*>(reveal_ref(r)));           \
   }
 
 #define WASM_DEFINE_SHARABLE_REF(name, Name) \
@@ -2527,11 +2561,11 @@ WASM_DEFINE_REF_BASE(ref, wasm::Ref)
 extern "C++" {
 
 inline auto is_empty(wasm_val_t v) -> bool {
-  return !is_ref(reveal(static_cast<wasm_valkind_enum>(v.kind))) || !v.of.ref;
+  return !is_ref(reveal_valkind(v.kind)) || !v.of.ref;
 }
 
-inline auto hide(wasm::Val v) -> wasm_val_t {
-  wasm_val_t v2 = {hide(v.kind()), {}};
+inline auto hide_val(wasm::Val v) -> wasm_val_t {
+  wasm_val_t v2 = {hide_valkind(v.kind()), {}};
   switch (v.kind()) {
     case wasm::I32:
       v2.of.i32 = v.i32();
@@ -2547,7 +2581,7 @@ inline auto hide(wasm::Val v) -> wasm_val_t {
       break;
     case wasm::ANYREF:
     case wasm::FUNCREF:
-      v2.of.ref = hide(v.ref());
+      v2.of.ref = hide_ref(v.ref());
       break;
     default:
       UNREACHABLE();
@@ -2555,8 +2589,8 @@ inline auto hide(wasm::Val v) -> wasm_val_t {
   return v2;
 }
 
-inline auto release(wasm::Val v) -> wasm_val_t {
-  wasm_val_t v2 = {hide(v.kind()), {}};
+inline auto release_val(wasm::Val v) -> wasm_val_t {
+  wasm_val_t v2 = {hide_valkind(v.kind()), {}};
   switch (v.kind()) {
     case wasm::I32:
       v2.of.i32 = v.i32();
@@ -2572,7 +2606,7 @@ inline auto release(wasm::Val v) -> wasm_val_t {
       break;
     case wasm::ANYREF:
     case wasm::FUNCREF:
-      v2.of.ref = release(v.release_ref());
+      v2.of.ref = release_ref(v.release_ref());
       break;
     default:
       UNREACHABLE();
@@ -2580,8 +2614,8 @@ inline auto release(wasm::Val v) -> wasm_val_t {
   return v2;
 }
 
-inline auto adopt(wasm_val_t v) -> wasm::Val {
-  switch (reveal(static_cast<wasm_valkind_enum>(v.kind))) {
+inline auto adopt_val(wasm_val_t v) -> wasm::Val {
+  switch (reveal_valkind(v.kind)) {
     case wasm::I32:
       return wasm::Val(v.of.i32);
     case wasm::I64:
@@ -2592,7 +2626,7 @@ inline auto adopt(wasm_val_t v) -> wasm::Val {
       return wasm::Val(v.of.f64);
     case wasm::ANYREF:
     case wasm::FUNCREF:
-      return wasm::Val(adopt(v.of.ref));
+      return wasm::Val(adopt_ref(v.of.ref));
     default:
       UNREACHABLE();
   }
@@ -2607,9 +2641,9 @@ struct borrowed_val {
   }
 };
 
-inline auto borrow(const wasm_val_t* v) -> borrowed_val {
+inline auto borrow_val(const wasm_val_t* v) -> borrowed_val {
   wasm::Val v2;
-  switch (reveal(static_cast<wasm_valkind_enum>(v->kind))) {
+  switch (reveal_valkind(v->kind)) {
     case wasm::I32:
       v2 = wasm::Val(v->of.i32);
       break;
@@ -2624,7 +2658,7 @@ inline auto borrow(const wasm_val_t* v) -> borrowed_val {
       break;
     case wasm::ANYREF:
     case wasm::FUNCREF:
-      v2 = wasm::Val(adopt(v->of.ref));
+      v2 = wasm::Val(adopt_ref(v->of.ref));
       break;
     default:
       UNREACHABLE();
@@ -2640,9 +2674,9 @@ void wasm_val_vec_new(wasm_val_vec_t* out, size_t size,
                       wasm_val_t const data[]) {
   auto v2 = wasm::vec<wasm::Val>::make_uninitialized(size);
   for (size_t i = 0; i < v2.size(); ++i) {
-    v2[i] = adopt(data[i]);
+    v2[i] = adopt_val(data[i]);
   }
-  *out = release(std::move(v2));
+  *out = release_val_vec(std::move(v2));
 }
 
 void wasm_val_vec_copy(wasm_val_vec_t* out, wasm_val_vec_t* v) {
@@ -2650,21 +2684,21 @@ void wasm_val_vec_copy(wasm_val_vec_t* out, wasm_val_vec_t* v) {
   for (size_t i = 0; i < v2.size(); ++i) {
     wasm_val_t val;
     wasm_val_copy(&v->data[i], &val);
-    v2[i] = adopt(val);
+    v2[i] = adopt_val(val);
   }
-  *out = release(std::move(v2));
+  *out = release_val_vec(std::move(v2));
 }
 
 void wasm_val_delete(wasm_val_t* v) {
-  if (is_ref(reveal(static_cast<wasm_valkind_enum>(v->kind)))) {
-    adopt(v->of.ref);
+  if (is_ref(reveal_valkind(v->kind))) {
+    adopt_ref(v->of.ref);
   }
 }
 
 void wasm_val_copy(wasm_val_t* out, const wasm_val_t* v) {
   *out = *v;
-  if (is_ref(reveal(static_cast<wasm_valkind_enum>(v->kind)))) {
-    out->of.ref = release(v->of.ref->copy());
+  if (is_ref(reveal_valkind(v->kind))) {
+    out->of.ref = release_ref(v->of.ref->copy());
   }
 }
 
@@ -2677,22 +2711,22 @@ WASM_DEFINE_OWN(frame, wasm::Frame)
 WASM_DEFINE_VEC(frame, wasm::Frame, *)
 
 wasm_frame_t* wasm_frame_copy(const wasm_frame_t* frame) {
-  return release(frame->copy());
+  return release_frame(frame->copy());
 }
 
 wasm_instance_t* wasm_frame_instance(const wasm_frame_t* frame);
 // Defined below along with wasm_instance_t.
 
 uint32_t wasm_frame_func_index(const wasm_frame_t* frame) {
-  return reveal(frame)->func_index();
+  return reveal_frame(frame)->func_index();
 }
 
 size_t wasm_frame_func_offset(const wasm_frame_t* frame) {
-  return reveal(frame)->func_offset();
+  return reveal_frame(frame)->func_offset();
 }
 
 size_t wasm_frame_module_offset(const wasm_frame_t* frame) {
-  return reveal(frame)->module_offset();
+  return reveal_frame(frame)->module_offset();
 }
 
 // Traps
@@ -2700,20 +2734,20 @@ size_t wasm_frame_module_offset(const wasm_frame_t* frame) {
 WASM_DEFINE_REF(trap, wasm::Trap)
 
 wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t* message) {
-  auto message_ = borrow(message);
-  return release(wasm::Trap::make(store, message_.it));
+  auto message_ = borrow_byte_vec(message);
+  return release_trap(wasm::Trap::make(store, message_.it));
 }
 
 void wasm_trap_message(const wasm_trap_t* trap, wasm_message_t* out) {
-  *out = release(reveal(trap)->message());
+  *out = release_byte_vec(reveal_trap(trap)->message());
 }
 
 wasm_frame_t* wasm_trap_origin(const wasm_trap_t* trap) {
-  return release(reveal(trap)->origin());
+  return release_frame(reveal_trap(trap)->origin());
 }
 
 void wasm_trap_trace(const wasm_trap_t* trap, wasm_frame_vec_t* out) {
-  *out = release(reveal(trap)->trace());
+  *out = release_frame_vec(reveal_trap(trap)->trace());
 }
 
 // Foreign Objects
@@ -2721,7 +2755,7 @@ void wasm_trap_trace(const wasm_trap_t* trap, wasm_frame_vec_t* out) {
 WASM_DEFINE_REF(foreign, wasm::Foreign)
 
 wasm_foreign_t* wasm_foreign_new(wasm_store_t* store) {
-  return release(wasm::Foreign::make(store));
+  return release_foreign(wasm::Foreign::make(store));
 }
 
 // Modules
@@ -2729,43 +2763,43 @@ wasm_foreign_t* wasm_foreign_new(wasm_store_t* store) {
 WASM_DEFINE_SHARABLE_REF(module, wasm::Module)
 
 bool wasm_module_validate(wasm_store_t* store, const wasm_byte_vec_t* binary) {
-  auto binary_ = borrow(binary);
+  auto binary_ = borrow_byte_vec(binary);
   return wasm::Module::validate(store, binary_.it);
 }
 
 wasm_module_t* wasm_module_new(wasm_store_t* store,
                                const wasm_byte_vec_t* binary) {
-  auto binary_ = borrow(binary);
-  return release(wasm::Module::make(store, binary_.it));
+  auto binary_ = borrow_byte_vec(binary);
+  return release_module(wasm::Module::make(store, binary_.it));
 }
 
 void wasm_module_imports(const wasm_module_t* module,
                          wasm_importtype_vec_t* out) {
-  *out = release(reveal(module)->imports());
+  *out = release_importtype_vec(reveal_module(module)->imports());
 }
 
 void wasm_module_exports(const wasm_module_t* module,
                          wasm_exporttype_vec_t* out) {
-  *out = release(reveal(module)->exports());
+  *out = release_exporttype_vec(reveal_module(module)->exports());
 }
 
 void wasm_module_serialize(const wasm_module_t* module, wasm_byte_vec_t* out) {
-  *out = release(reveal(module)->serialize());
+  *out = release_byte_vec(reveal_module(module)->serialize());
 }
 
 wasm_module_t* wasm_module_deserialize(wasm_store_t* store,
                                        const wasm_byte_vec_t* binary) {
-  auto binary_ = borrow(binary);
-  return release(wasm::Module::deserialize(store, binary_.it));
+  auto binary_ = borrow_byte_vec(binary);
+  return release_module(wasm::Module::deserialize(store, binary_.it));
 }
 
 wasm_shared_module_t* wasm_module_share(const wasm_module_t* module) {
-  return release(reveal(module)->share());
+  return release_shared_module(reveal_module(module)->share());
 }
 
 wasm_module_t* wasm_module_obtain(wasm_store_t* store,
                                   const wasm_shared_module_t* shared) {
-  return release(wasm::Module::obtain(store, shared));
+  return release_module(wasm::Module::obtain(store, shared));
 }
 
 // Function Instances
@@ -2777,7 +2811,7 @@ extern "C++" {
 auto wasm_callback(void* env, const wasm::Val args[], wasm::Val results[])
     -> wasm::own<wasm::Trap*> {
   auto f = reinterpret_cast<wasm_func_callback_t>(env);
-  return adopt(f(hide(args), hide(results)));
+  return adopt_trap(f(hide_val_vec(args), hide_val_vec(results)));
 }
 
 struct wasm_callback_env_t {
@@ -2789,7 +2823,8 @@ struct wasm_callback_env_t {
 auto wasm_callback_with_env(void* env, const wasm::Val args[],
                             wasm::Val results[]) -> wasm::own<wasm::Trap*> {
   auto t = static_cast<wasm_callback_env_t*>(env);
-  return adopt(t->callback(t->env, hide(args), hide(results)));
+  return adopt_trap(
+      t->callback(t->env, hide_val_vec(args), hide_val_vec(results)));
 }
 
 void wasm_callback_env_finalizer(void* env) {
@@ -2802,8 +2837,8 @@ void wasm_callback_env_finalizer(void* env) {
 
 wasm_func_t* wasm_func_new(wasm_store_t* store, const wasm_functype_t* type,
                            wasm_func_callback_t callback) {
-  return release(wasm::Func::make(store, type, wasm_callback,
-                                  reinterpret_cast<void*>(callback)));
+  return release_func(wasm::Func::make(store, type, wasm_callback,
+                                       reinterpret_cast<void*>(callback)));
 }
 
 wasm_func_t* wasm_func_new_with_env(wasm_store_t* store,
@@ -2811,12 +2846,12 @@ wasm_func_t* wasm_func_new_with_env(wasm_store_t* store,
                                     wasm_func_callback_with_env_t callback,
                                     void* env, void (*finalizer)(void*)) {
   auto env2 = new wasm_callback_env_t{callback, env, finalizer};
-  return release(wasm::Func::make(store, type, wasm_callback_with_env, env2,
-                                  wasm_callback_env_finalizer));
+  return release_func(wasm::Func::make(store, type, wasm_callback_with_env,
+                                       env2, wasm_callback_env_finalizer));
 }
 
 wasm_functype_t* wasm_func_type(const wasm_func_t* func) {
-  return release(func->type());
+  return release_functype(func->type());
 }
 
 size_t wasm_func_param_arity(const wasm_func_t* func) {
@@ -2829,7 +2864,8 @@ size_t wasm_func_result_arity(const wasm_func_t* func) {
 
 wasm_trap_t* wasm_func_call(const wasm_func_t* func, const wasm_val_t args[],
                             wasm_val_t results[]) {
-  return release(func->call(reveal(args), reveal(results)));
+  return release_trap(
+      func->call(reveal_val_vec(args), reveal_val_vec(results)));
 }
 
 // Global Instances
@@ -2839,20 +2875,20 @@ WASM_DEFINE_REF(global, wasm::Global)
 wasm_global_t* wasm_global_new(wasm_store_t* store,
                                const wasm_globaltype_t* type,
                                const wasm_val_t* val) {
-  auto val_ = borrow(val);
-  return release(wasm::Global::make(store, type, val_.it));
+  auto val_ = borrow_val(val);
+  return release_global(wasm::Global::make(store, type, val_.it));
 }
 
 wasm_globaltype_t* wasm_global_type(const wasm_global_t* global) {
-  return release(global->type());
+  return release_globaltype(global->type());
 }
 
 void wasm_global_get(const wasm_global_t* global, wasm_val_t* out) {
-  *out = release(global->get());
+  *out = release_val(global->get());
 }
 
 void wasm_global_set(wasm_global_t* global, const wasm_val_t* val) {
-  auto val_ = borrow(val);
+  auto val_ = borrow_val(val);
   global->set(val_.it);
 }
 
@@ -2862,15 +2898,15 @@ WASM_DEFINE_REF(table, wasm::Table)
 
 wasm_table_t* wasm_table_new(wasm_store_t* store, const wasm_tabletype_t* type,
                              wasm_ref_t* ref) {
-  return release(wasm::Table::make(store, type, ref));
+  return release_table(wasm::Table::make(store, type, ref));
 }
 
 wasm_tabletype_t* wasm_table_type(const wasm_table_t* table) {
-  return release(table->type());
+  return release_tabletype(table->type());
 }
 
 wasm_ref_t* wasm_table_get(const wasm_table_t* table, wasm_table_size_t index) {
-  return release(table->get(index));
+  return release_ref(table->get(index));
 }
 
 bool wasm_table_set(wasm_table_t* table, wasm_table_size_t index,
@@ -2893,11 +2929,11 @@ WASM_DEFINE_REF(memory, wasm::Memory)
 
 wasm_memory_t* wasm_memory_new(wasm_store_t* store,
                                const wasm_memorytype_t* type) {
-  return release(wasm::Memory::make(store, type));
+  return release_memory(wasm::Memory::make(store, type));
 }
 
 wasm_memorytype_t* wasm_memory_type(const wasm_memory_t* memory) {
-  return release(memory->type());
+  return release_memorytype(memory->type());
 }
 
 wasm_byte_t* wasm_memory_data(wasm_memory_t* memory) { return memory->data(); }
@@ -2920,64 +2956,64 @@ WASM_DEFINE_REF(extern, wasm::Extern)
 WASM_DEFINE_VEC(extern, wasm::Extern, *)
 
 wasm_externkind_t wasm_extern_kind(const wasm_extern_t* external) {
-  return hide(external->kind());
+  return hide_externkind(external->kind());
 }
 wasm_externtype_t* wasm_extern_type(const wasm_extern_t* external) {
-  return release(external->type());
+  return release_externtype(external->type());
 }
 
 wasm_extern_t* wasm_func_as_extern(wasm_func_t* func) {
-  return hide(static_cast<wasm::Extern*>(reveal(func)));
+  return hide_extern(static_cast<wasm::Extern*>(reveal_func(func)));
 }
 wasm_extern_t* wasm_global_as_extern(wasm_global_t* global) {
-  return hide(static_cast<wasm::Extern*>(reveal(global)));
+  return hide_extern(static_cast<wasm::Extern*>(reveal_global(global)));
 }
 wasm_extern_t* wasm_table_as_extern(wasm_table_t* table) {
-  return hide(static_cast<wasm::Extern*>(reveal(table)));
+  return hide_extern(static_cast<wasm::Extern*>(reveal_table(table)));
 }
 wasm_extern_t* wasm_memory_as_extern(wasm_memory_t* memory) {
-  return hide(static_cast<wasm::Extern*>(reveal(memory)));
+  return hide_extern(static_cast<wasm::Extern*>(reveal_memory(memory)));
 }
 
 const wasm_extern_t* wasm_func_as_extern_const(const wasm_func_t* func) {
-  return hide(static_cast<const wasm::Extern*>(reveal(func)));
+  return hide_extern(static_cast<const wasm::Extern*>(reveal_func(func)));
 }
 const wasm_extern_t* wasm_global_as_extern_const(const wasm_global_t* global) {
-  return hide(static_cast<const wasm::Extern*>(reveal(global)));
+  return hide_extern(static_cast<const wasm::Extern*>(reveal_global(global)));
 }
 const wasm_extern_t* wasm_table_as_extern_const(const wasm_table_t* table) {
-  return hide(static_cast<const wasm::Extern*>(reveal(table)));
+  return hide_extern(static_cast<const wasm::Extern*>(reveal_table(table)));
 }
 const wasm_extern_t* wasm_memory_as_extern_const(const wasm_memory_t* memory) {
-  return hide(static_cast<const wasm::Extern*>(reveal(memory)));
+  return hide_extern(static_cast<const wasm::Extern*>(reveal_memory(memory)));
 }
 
 wasm_func_t* wasm_extern_as_func(wasm_extern_t* external) {
-  return hide(external->func());
+  return hide_func(external->func());
 }
 wasm_global_t* wasm_extern_as_global(wasm_extern_t* external) {
-  return hide(external->global());
+  return hide_global(external->global());
 }
 wasm_table_t* wasm_extern_as_table(wasm_extern_t* external) {
-  return hide(external->table());
+  return hide_table(external->table());
 }
 wasm_memory_t* wasm_extern_as_memory(wasm_extern_t* external) {
-  return hide(external->memory());
+  return hide_memory(external->memory());
 }
 
 const wasm_func_t* wasm_extern_as_func_const(const wasm_extern_t* external) {
-  return hide(external->func());
+  return hide_func(external->func());
 }
 const wasm_global_t* wasm_extern_as_global_const(
     const wasm_extern_t* external) {
-  return hide(external->global());
+  return hide_global(external->global());
 }
 const wasm_table_t* wasm_extern_as_table_const(const wasm_extern_t* external) {
-  return hide(external->table());
+  return hide_table(external->table());
 }
 const wasm_memory_t* wasm_extern_as_memory_const(
     const wasm_extern_t* external) {
-  return hide(external->memory());
+  return hide_memory(external->memory());
 }
 
 // Module Instances
@@ -2987,17 +3023,17 @@ WASM_DEFINE_REF(instance, wasm::Instance)
 wasm_instance_t* wasm_instance_new(wasm_store_t* store,
                                    const wasm_module_t* module,
                                    const wasm_extern_t* const imports[]) {
-  return release(wasm::Instance::make(
+  return release_instance(wasm::Instance::make(
       store, module, reinterpret_cast<const wasm::Extern* const*>(imports)));
 }
 
 void wasm_instance_exports(const wasm_instance_t* instance,
                            wasm_extern_vec_t* out) {
-  *out = release(instance->exports());
+  *out = release_extern_vec(instance->exports());
 }
 
 wasm_instance_t* wasm_frame_instance(const wasm_frame_t* frame) {
-  return hide(reveal(frame)->instance());
+  return hide_instance(reveal_frame(frame)->instance());
 }
 
 #undef WASM_DEFINE_OWN