c-api: component-model: Lookup function from an instance (#10675)

* c-api: component-model: Lookup function from an instance

* c-api: component-model: Take strings as `wasm_name_t`

* Use export indices

* Shared `CHECK_ERR` macro

* Pass names as a pointer and a size, return nullable pointers

* Use `std::str::from_utf8()` instead of `str::from_utf8()`

* Remove doc link?

Author: MangoPeachGrape

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

@@ -2,6 +2,7 @@
 #define WASMTIME_COMPONENT_H
 
 #include <wasmtime/component/component.h>
+#include <wasmtime/component/func.h>
 #include <wasmtime/component/instance.h>
 #include <wasmtime/component/linker.h>
 

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

@@ -108,6 +108,33 @@ wasmtime_component_clone(const wasmtime_component_t *component);
  */
 WASM_API_EXTERN void wasmtime_component_delete(wasmtime_component_t *component);
 
+typedef struct wasmtime_component_export_index_t
+    wasmtime_component_export_index_t;
+
+/**
+ * \brief Looks up a specific export of this component by \p name optionally
+ * nested within the \p instance provided.
+ *
+ * \param component the component to look up \p name in
+ * \param instance_export_index optional (i.e. nullable) instance to look up in
+ * \param name the name of the export
+ * \param name_len length of \p name in bytes
+ * \return export index if found, else NULL
+ */
+WASM_API_EXTERN wasmtime_component_export_index_t *
+wasmtime_component_get_export_index(
+    const wasmtime_component_t *component,
+    const wasmtime_component_export_index_t *instance_export_index,
+    const char *name, size_t name_len);
+
+/**
+ * \brief Deletes a #wasmtime_component_export_index_t
+ *
+ * \param export_index the export index to delete
+ */
+WASM_API_EXTERN void wasmtime_component_export_index_delete(
+    wasmtime_component_export_index_t *export_index);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

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

@@ -0,0 +1,32 @@
+#ifndef WASMTIME_COMPONENT_FUNC_H
+#define WASMTIME_COMPONENT_FUNC_H
+
+#include <wasmtime/conf.h>
+
+#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// \brief Representation of a function in Wasmtime.
+///
+/// Functions in Wasmtime are represented as an index into a store and don't
+/// have any data or destructor associated with the value. Functions cannot
+/// interoperate between #wasmtime_store_t instances and if the wrong function
+/// is passed to the wrong store then it may trigger an assertion to abort the
+/// process.
+typedef struct wasmtime_component_func {
+  /// Internal identifier of what store this belongs to, never zero.
+  uint64_t store_id;
+  /// Internal index within the store.
+  size_t index;
+} wasmtime_component_func_t;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_FEATURE_COMPONENT_MODEL
+
+#endif // WASMTIME_COMPONENT_FUNC_H

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

@@ -1,7 +1,10 @@
 #ifndef WASMTIME_COMPONENT_INSTANCE_H
 #define WASMTIME_COMPONENT_INSTANCE_H
 
+#include <wasmtime/component/component.h>
+#include <wasmtime/component/func.h>
 #include <wasmtime/conf.h>
+#include <wasmtime/store.h>
 
 #ifdef WASMTIME_FEATURE_COMPONENT_MODEL
 
@@ -23,6 +26,38 @@ typedef struct wasmtime_component_instance {
   size_t index;
 } wasmtime_component_instance_t;
 
+/**
+ * \brief A methods similar to \fn wasmtime_component_get_export_index() except
+ * for this instance.
+ *
+ * \param instance the instance to look up \p name in
+ * \param context the context where \p instance lives in
+ * \param instance_export_index optional (i.e. nullable) instance to look up in
+ * \param name the name of the export
+ * \param name_len length of \p name in bytes
+ * \return export index if found, else NULL
+ */
+WASM_API_EXTERN wasmtime_component_export_index_t *
+wasmtime_component_instance_get_export_index(
+    const wasmtime_component_instance_t *instance, wasmtime_context_t *context,
+    const wasmtime_component_export_index_t *instance_export_index,
+    const char *name, size_t name_len);
+
+/**
+ * \brief Looks up an exported function by name within this
+ * #wasmtime_component_instance_t.
+ *
+ * \param instance the instance to look up this name in
+ * \param context the store that \p instance lives in
+ * \param export_index the export index of the function
+ * \param func_out if found, the function corresponding to \p name
+ * \return boolean marking if a function for \p name was found
+ */
+WASM_API_EXTERN bool wasmtime_component_instance_get_func(
+    const wasmtime_component_instance_t *instance, wasmtime_context_t *context,
+    const wasmtime_component_export_index_t *export_index,
+    wasmtime_component_func_t *func_out);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

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

@@ -81,12 +81,14 @@ wasmtime_component_linker_delete(wasmtime_component_linker_t *linker);
  *
  * \param linker_instance the linker instance from which the new one is created
  * \param name new instance name
+ * \param name_len length of \p name in bytes
  * \param linker_instance_out on success, the new #component_linker_instance_t
  * \return on success `NULL`, otherwise an error
  */
 WASM_API_EXTERN wasmtime_error_t *
 wasmtime_component_linker_instance_add_instance(
     wasmtime_component_linker_instance_t *linker_instance, const char *name,
+    size_t name_len,
     wasmtime_component_linker_instance_t **linker_instance_out);
 
 /**
@@ -98,12 +100,13 @@ wasmtime_component_linker_instance_add_instance(
  *
  * \param linker_instance the instance to define the module in
  * \param name the module name
+ * \param name_len length of \p name in bytes
  * \param module the module
  * \return on success `NULL`, otherwise an error
  */
 WASM_API_EXTERN wasmtime_error_t *wasmtime_component_linker_instance_add_module(
     wasmtime_component_linker_instance_t *linker_instance, const char *name,
-    const wasmtime_module_t *module);
+    size_t name_len, const wasmtime_module_t *module);
 
 /**
  * \brief Deletes a #wasmtime_component_linker_instance_t

crates/c-api/src/component/component.rs

@@ -1,7 +1,7 @@
 use std::ffi::{c_char, CStr};
 
 use anyhow::Context;
-use wasmtime::component::Component;
+use wasmtime::component::{Component, ComponentExportIndex};
 
 use crate::{wasm_byte_vec_t, wasm_config_t, wasm_engine_t, wasmtime_error_t};
 
@@ -85,3 +85,38 @@ pub unsafe extern "C" fn wasmtime_component_clone(
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmtime_component_delete(_component: Box<wasmtime_component_t>) {}
+
+#[repr(transparent)]
+pub struct wasmtime_component_export_index_t {
+    pub(crate) export_index: ComponentExportIndex,
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_component_get_export_index(
+    component: &wasmtime_component_t,
+    instance_export_index: *const wasmtime_component_export_index_t,
+    name: *const u8,
+    name_len: usize,
+) -> Option<Box<wasmtime_component_export_index_t>> {
+    let name = unsafe { std::slice::from_raw_parts(name, name_len) };
+    let Ok(name) = std::str::from_utf8(name) else {
+        return None;
+    };
+
+    let instance_export_index = if instance_export_index.is_null() {
+        None
+    } else {
+        Some((*instance_export_index).export_index)
+    };
+
+    component
+        .component
+        .get_export_index(instance_export_index.as_ref(), &name)
+        .map(|export_index| Box::new(wasmtime_component_export_index_t { export_index }))
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_component_export_index_delete(
+    _export_index: Box<wasmtime_component_export_index_t>,
+) {
+}

crates/c-api/src/component/instance.rs

@@ -0,0 +1,44 @@
+use wasmtime::component::{Func, Instance};
+
+use crate::WasmtimeStoreContextMut;
+
+use super::wasmtime_component_export_index_t;
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_component_instance_get_export_index(
+    instance: &Instance,
+    context: WasmtimeStoreContextMut<'_>,
+    instance_export_index: *const wasmtime_component_export_index_t,
+    name: *const u8,
+    name_len: usize,
+) -> Option<Box<wasmtime_component_export_index_t>> {
+    let name = unsafe { std::slice::from_raw_parts(name, name_len) };
+    let Ok(name) = std::str::from_utf8(name) else {
+        return None;
+    };
+
+    let instance_export_index = if instance_export_index.is_null() {
+        None
+    } else {
+        Some((*instance_export_index).export_index)
+    };
+
+    instance
+        .get_export_index(context, instance_export_index.as_ref(), &name)
+        .map(|export_index| Box::new(wasmtime_component_export_index_t { export_index }))
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_component_instance_get_func(
+    instance: &Instance,
+    context: WasmtimeStoreContextMut<'_>,
+    export_index: &wasmtime_component_export_index_t,
+    func_out: &mut Func,
+) -> bool {
+    if let Some(func) = instance.get_func(context, export_index.export_index) {
+        *func_out = func;
+        true
+    } else {
+        false
+    }
+}

crates/c-api/src/component/linker.rs

@@ -1,6 +1,3 @@
-use std::ffi::{c_char, CStr};
-
-use anyhow::Context;
 use wasmtime::component::{Instance, Linker, LinkerInstance};
 
 use crate::{
@@ -57,15 +54,16 @@ pub unsafe extern "C" fn wasmtime_component_linker_delete(
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmtime_component_linker_instance_add_instance<'a>(
     linker_instance: &'a mut wasmtime_component_linker_instance_t<'a>,
-    name: *const c_char,
+    name: *const u8,
+    name_len: usize,
     linker_instance_out: &mut *mut wasmtime_component_linker_instance_t<'a>,
 ) -> Option<Box<wasmtime_error_t>> {
-    let name = unsafe { CStr::from_ptr(name) };
-    let result = name
-        .to_str()
-        .context("input name is not valid utf-8")
-        .and_then(|name| linker_instance.linker_instance.instance(name));
+    let name = unsafe { std::slice::from_raw_parts(name, name_len) };
+    let Ok(name) = std::str::from_utf8(name) else {
+        return crate::bad_utf8();
+    };
 
+    let result = linker_instance.linker_instance.instance(&name);
     crate::handle_result(result, |linker_instance| {
         *linker_instance_out = Box::into_raw(Box::new(wasmtime_component_linker_instance_t {
             linker_instance,
@@ -76,14 +74,18 @@ pub unsafe extern "C" fn wasmtime_component_linker_instance_add_instance<'a>(
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmtime_component_linker_instance_add_module(
     linker_instance: &mut wasmtime_component_linker_instance_t,
-    name: *const c_char,
+    name: *const u8,
+    name_len: usize,
     module: &wasmtime_module_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    let name = unsafe { CStr::from_ptr(name) };
-    let result = name
-        .to_str()
-        .context("input name is not valid utf-8")
-        .and_then(|name| linker_instance.linker_instance.module(name, &module.module));
+    let name = unsafe { std::slice::from_raw_parts(name, name_len) };
+    let Ok(name) = std::str::from_utf8(name) else {
+        return crate::bad_utf8();
+    };
+
+    let result = linker_instance
+        .linker_instance
+        .module(&name, &module.module);
 
     crate::handle_result(result, |_| ())
 }

crates/c-api/src/component/mod.rs

@@ -1,5 +1,7 @@
 mod component;
+mod instance;
 mod linker;
 
 pub use component::*;
+pub use instance::*;
 pub use linker::*;

crates/c-api/tests/CMakeLists.txt

@@ -33,6 +33,7 @@ add_capi_test(tests FILES
   func.cc
   component/instantiate.cc
   component/define_module.cc
+  component/lookup_func.cc
   error.cc
   config.cc
   wat.cc