[39.0.0] Fill out type information for components in C API (#11988)

* Simplify C++ binding definitions (#11936)

This commit adds a shared macro to simplify ownership management in the
C++ API and to additionally have a uniform API across types. This is
inspired by the component model work where I felt like I was
copy/pasting quite a lot and wanted to cut down on that.

* Fill out type information for components in C API  (#11937)

* Fill out type information for components in C API

I've concluded that I'll want this for wasmtime-py so this fills out
type reflection for various items in the C API. This then additionally
extends the C++ API as well.

prtest:full

* Update crates/c-api/include/wasmtime/component/types/func.h

Co-authored-by: Joel Dice <[email protected]>

---------

Co-authored-by: Joel Dice <[email protected]>

---------

Co-authored-by: Joel Dice <[email protected]>

Author: alexcrichton

crates/c-api/include/wasmtime/component.h

@@ -5,6 +5,7 @@
 #include <wasmtime/component/func.h>
 #include <wasmtime/component/instance.h>
 #include <wasmtime/component/linker.h>
+#include <wasmtime/component/types.h>
 #include <wasmtime/component/val.h>
 
 #endif // WASMTIME_COMPONENT_H

crates/c-api/include/wasmtime/component.hh

@@ -7,6 +7,7 @@
 #include <wasmtime/component/func.hh>
 #include <wasmtime/component/instance.hh>
 #include <wasmtime/component/linker.hh>
+#include <wasmtime/component/types.hh>
 #include <wasmtime/component/val.hh>
 
 #endif // WASMTIME_COMPONENT_HH

crates/c-api/include/wasmtime/component/component.h

@@ -4,6 +4,7 @@
 #define WASMTIME_COMPONENT_COMPONENT_H
 
 #include <wasm.h>
+#include <wasmtime/component/types/component.h>
 #include <wasmtime/conf.h>
 #include <wasmtime/error.h>
 
@@ -102,6 +103,15 @@ wasmtime_component_deserialize_file(const wasm_engine_t *engine,
 WASM_API_EXTERN wasmtime_component_t *
 wasmtime_component_clone(const wasmtime_component_t *component);
 
+/**
+ * \brief Returns the type of this component.
+ *
+ * The returned pointer must be deallocatd with
+ * `wasmtime_component_type_delete`.
+ */
+WASM_API_EXTERN wasmtime_component_type_t *
+wasmtime_component_type(const wasmtime_component_t *component);
+
 /**
  * \brief Deletes a #wasmtime_component_t created by #wasmtime_component_new
  *

crates/c-api/include/wasmtime/component/component.hh

@@ -14,6 +14,7 @@
 #include <string_view>
 #include <vector>
 #include <wasmtime/component/component.h>
+#include <wasmtime/component/types/component.hh>
 #include <wasmtime/engine.hh>
 #include <wasmtime/error.hh>
 #include <wasmtime/span.hh>
@@ -29,76 +30,14 @@ namespace component {
  * instances.
  */
 class ExportIndex {
-  friend class Component;
-
-  struct deleter {
-    void operator()(wasmtime_component_export_index_t *p) const {
-      wasmtime_component_export_index_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_component_export_index_t, deleter> ptr;
-
-public:
-  /// \brief Constructs an ExportIndex from the underlying C API struct.
-  explicit ExportIndex(wasmtime_component_export_index_t *raw) : ptr(raw) {}
-
-  /// Copies another index into this one.
-  ExportIndex(const ExportIndex &other)
-      : ptr(wasmtime_component_export_index_clone(other.ptr.get())) {}
-  /// Copies another index into this one.
-  ExportIndex &operator=(const ExportIndex &other) {
-    ptr.reset(wasmtime_component_export_index_clone(other.ptr.get()));
-    return *this;
-  }
-
-  ~ExportIndex() = default;
-  /// Moves resources from another component into this one.
-  ExportIndex(ExportIndex &&other) = default;
-  /// Moves resources from another component into this one.
-  ExportIndex &operator=(ExportIndex &&other) = default;
-
-  /// \brief Returns the underlying C API pointer.
-  const wasmtime_component_export_index_t *capi() const { return ptr.get(); }
-
-  /// \brief Returns the underlying C API pointer.
-  wasmtime_component_export_index_t *capi() { return ptr.get(); }
+  WASMTIME_CLONE_WRAPPER(ExportIndex, wasmtime_component_export_index);
 };
 
 /**
  * \brief Representation of a compiled WebAssembly component.
  */
 class Component {
-  struct deleter {
-    void operator()(wasmtime_component_t *p) const {
-      wasmtime_component_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_component_t, deleter> ptr;
-
-  Component(wasmtime_component_t *raw) : ptr(raw) {}
-
-public:
-  /// Copies another component into this one.
-  Component(const Component &other)
-      : ptr(wasmtime_component_clone(other.ptr.get())) {}
-  /// Copies another component into this one.
-  Component &operator=(const Component &other) {
-    ptr.reset(wasmtime_component_clone(other.ptr.get()));
-    return *this;
-  }
-  ~Component() = default;
-  /// Moves resources from another component into this one.
-  Component(Component &&other) = default;
-  /// Moves resources from another component into this one.
-  Component &operator=(Component &&other) = default;
-
-  /// \brief Returns the underlying C API pointer.
-  const wasmtime_component_t *capi() const { return ptr.get(); }
-
-  /// \brief Returns the underlying C API pointer.
-  wasmtime_component_t *capi() { return ptr.get(); }
+  WASMTIME_CLONE_WRAPPER(Component, wasmtime_component);
 
 #ifdef WASMTIME_FEATURE_COMPILER
   /**
@@ -221,6 +160,11 @@ public:
     }
     return std::nullopt;
   };
+
+  /// \brief Returns the type of this component.
+  ComponentType type() const {
+    return ComponentType(wasmtime_component_type(ptr.get()));
+  }
 };
 
 } // namespace component

crates/c-api/include/wasmtime/component/func.h

@@ -3,6 +3,7 @@
 #ifndef WASMTIME_COMPONENT_FUNC_H
 #define WASMTIME_COMPONENT_FUNC_H
 
+#include <wasmtime/component/types/func.h>
 #include <wasmtime/component/val.h>
 #include <wasmtime/conf.h>
 #include <wasmtime/error.h>
@@ -33,6 +34,14 @@ typedef struct wasmtime_component_func {
   uint32_t __private2;
 } wasmtime_component_func_t;
 
+/// \brief Returns the type of this function.
+///
+/// The caller must deallocate the returned pointer with
+/// `wasmtime_component_func_type_delete`.
+WASM_API_EXTERN wasmtime_component_func_type_t *
+wasmtime_component_func_type(const wasmtime_component_func_t *func,
+                             wasmtime_context_t *context);
+
 /**
  * \brief Invokes \p func with the \p args given and returns the result.
  *

crates/c-api/include/wasmtime/component/func.hh

@@ -9,6 +9,7 @@
 
 #include <string_view>
 #include <wasmtime/component/func.h>
+#include <wasmtime/component/types/func.hh>
 #include <wasmtime/component/val.hh>
 #include <wasmtime/error.hh>
 #include <wasmtime/span.hh>
@@ -54,6 +55,11 @@ public:
     }
     return std::monostate();
   }
+
+  /// \brief Returns the type of this function.
+  FuncType type(Store::Context cx) const {
+    return FuncType(wasmtime_component_func_type(&func, cx.capi()));
+  }
 };
 
 } // namespace component

crates/c-api/include/wasmtime/component/linker.h

@@ -6,6 +6,7 @@
 #include <wasm.h>
 #include <wasmtime/component/component.h>
 #include <wasmtime/component/instance.h>
+#include <wasmtime/component/types/func.h>
 #include <wasmtime/conf.h>
 #include <wasmtime/error.h>
 #include <wasmtime/module.h>
@@ -134,8 +135,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_component_linker_instance_add_module(
 
 /// Type of the callback used in #wasmtime_component_linker_instance_add_func
 typedef wasmtime_error_t *(*wasmtime_component_func_callback_t)(
-    void *, wasmtime_context_t *, const wasmtime_component_val_t *, size_t,
-    wasmtime_component_val_t *, size_t);
+    void *, wasmtime_context_t *, const wasmtime_component_func_type_t *,
+    wasmtime_component_val_t *, size_t, wasmtime_component_val_t *, size_t);
 
 /**
  * \brief Define a function within this instance.

crates/c-api/include/wasmtime/component/linker.hh

@@ -26,24 +26,7 @@ namespace component {
  * `Linker` can also be used to link in WASI functions to instantiate a module.
  */
 class LinkerInstance {
-  struct deleter {
-    void operator()(wasmtime_component_linker_instance_t *p) const {
-      wasmtime_component_linker_instance_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_component_linker_instance_t, deleter> ptr;
-
-public:
-  /// Creates a new linker instance from the given C API pointer.
-  explicit LinkerInstance(wasmtime_component_linker_instance_t *ptr)
-      : ptr(ptr) {}
-
-  /// \brief Returns the underlying C API pointer.
-  const wasmtime_component_linker_instance_t *capi() const { return ptr.get(); }
-
-  /// \brief Returns the underlying C API pointer.
-  wasmtime_component_linker_instance_t *capi() { return ptr.get(); }
+  WASMTIME_OWN_WRAPPER(LinkerInstance, wasmtime_component_linker_instance);
 
   /**
    * \brief Adds a module to this linker instance under the specified name.
@@ -78,17 +61,22 @@ private:
   template <typename F>
   static wasmtime_error_t *
   raw_callback(void *env, wasmtime_context_t *store,
-               const wasmtime_component_val_t *args, size_t nargs,
+               const wasmtime_component_func_type_t *ty_const,
+               wasmtime_component_val_t *args, size_t nargs,
                wasmtime_component_val_t *results, size_t nresults) {
     static_assert(alignof(Val) == alignof(wasmtime_component_val_t));
     static_assert(sizeof(Val) == sizeof(wasmtime_component_val_t));
+    wasmtime_component_func_type_t *ty =
+        const_cast<wasmtime_component_func_type_t *>(ty_const);
     F *func = reinterpret_cast<F *>(env);
-    Span<const Val> args_span(Val::from_capi(args), nargs);
+    Span<Val> args_span(Val::from_capi(args), nargs);
     Span<Val> results_span(Val::from_capi(results), nresults);
     Result<std::monostate> result =
-        (*func)(Store::Context(store), args_span, results_span);
+        (*func)(Store::Context(store), *FuncType::from_capi(&ty), args_span,
+                results_span);
+
     if (!result) {
-      return result.err().release();
+      return result.err().capi_release();
     }
     return nullptr;
   }
@@ -102,7 +90,7 @@ public:
   template <typename F,
             std::enable_if_t<
                 std::is_invocable_r_v<Result<std::monostate>, F, Store::Context,
-                                      Span<const Val>, Span<Val>>,
+                                      const FuncType &, Span<Val>, Span<Val>>,
                 bool> = true>
   Result<std::monostate> add_func(std::string_view name, F &&f) {
     auto *error = wasmtime_component_linker_instance_add_func(
@@ -127,7 +115,7 @@ private:
     F *func = reinterpret_cast<F *>(env);
     Result<std::monostate> result = (*func)(Store::Context(store), rep);
     if (!result) {
-      return result.err().release();
+      return result.err().capi_release();
     }
     return nullptr;
   }
@@ -160,15 +148,8 @@ public:
  * \brief Class used to instantiate a `Component` into an instance.
  */
 class Linker {
-  struct deleter {
-    void operator()(wasmtime_component_linker_t *p) const {
-      wasmtime_component_linker_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_component_linker_t, deleter> ptr;
+  WASMTIME_OWN_WRAPPER(Linker, wasmtime_component_linker);
 
-public:
   /// Creates a new linker which will instantiate in the given engine.
   explicit Linker(Engine &engine)
       : ptr(wasmtime_component_linker_new(engine.capi())) {}
@@ -234,12 +215,6 @@ public:
     return std::monostate();
   }
 #endif // WASMTIME_FEATURE_WASI
-
-  /// \brief Returns the underlying C API pointer.
-  const wasmtime_component_linker_t *capi() const { return ptr.get(); }
-
-  /// \brief Returns the underlying C API pointer.
-  wasmtime_component_linker_t *capi() { return ptr.get(); }
 };
 
 } // namespace component

crates/c-api/include/wasmtime/component/types.h

@@ -0,0 +1,13 @@
+/// \file wasmtime/component/types.h
+
+#ifndef WASMTIME_COMPONENT_TYPES_H
+#define WASMTIME_COMPONENT_TYPES_H
+
+#include <wasmtime/component/types/component.h>
+#include <wasmtime/component/types/func.h>
+#include <wasmtime/component/types/instance.h>
+#include <wasmtime/component/types/module.h>
+#include <wasmtime/component/types/resource.h>
+#include <wasmtime/component/types/val.h>
+
+#endif // WASMTIME_COMPONENT_TYPES_H

crates/c-api/include/wasmtime/component/types.hh

@@ -0,0 +1,12 @@
+/// \file wasmtime/component/types.hh
+
+#ifndef WASMTIME_COMPONENT_TYPES_HH
+#define WASMTIME_COMPONENT_TYPES_HH
+
+#include <wasmtime/component/types/component.hh>
+#include <wasmtime/component/types/func.hh>
+#include <wasmtime/component/types/instance.hh>
+#include <wasmtime/component/types/module.hh>
+#include <wasmtime/component/types/val.hh>
+
+#endif // WASMTIME_COMPONENT_TYPES_HH