wasmtime.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_HH
#define WASMTIME_HH
 
#include <any>
#include <array>
#include <cstdio>
#include <initializer_list>
#include <iosfwd>
#include <limits>
#include <memory>
#include <optional>
#include <ostream>
#include <variant>
#include <vector>
#ifdef __has_include
#if __has_include(<span>)
#include <span>
#endif
#endif
 
#include "wasmtime.h"
 
namespace wasmtime {
 
#ifdef __cpp_lib_span
 
template <typename T, std::size_t Extent = std::dynamic_extent>
using Span = std::span<T, Extent>;
 
#else
 
inline constexpr size_t dynamic_extent =
    std::numeric_limits<std::size_t>::max();
 
template <typename T, std::size_t Extent = dynamic_extent> class Span;
 
template <typename T> struct IsSpan : std::false_type {};
 
template <typename T, std::size_t Extent>
struct IsSpan<Span<T, Extent>> : std::true_type {};
 
template <typename T, std::size_t Extent> class Span {
  static_assert(Extent == dynamic_extent,
                "The current implementation supports dynamic-extent span only");
 
public:
  using iterator = T *;
 
  Span(T *t, std::size_t n) : ptr_{t}, size_{n} {}
 
  template <typename C,
            std::enable_if_t<
                !IsSpan<C>::value &&
                    std::is_pointer_v<decltype(std::declval<C &>().data())> &&
                    std::is_convertible_v<
                        std::remove_pointer_t<
                            decltype(std::declval<C &>().data())> (*)[],
                        T (*)[]> &&
                    std::is_convertible_v<decltype(std::declval<C>().size()),
                                          std::size_t>,
                int> = 0>
  Span(C &range) : ptr_{range.data()}, size_{range.size()} {}
 
  T &operator[](ptrdiff_t idx) const {
    return ptr_[idx]; // NOLINT
  }
 
  T *data() const { return ptr_; }
 
  std::size_t size() const { return size_; }
 
  iterator begin() const { return ptr_; }
 
  iterator end() const {
    return ptr_ + size_; // NOLINT
  }
 
  std::size_t size_bytes() const { return sizeof(T) * size_; }
 
private:
  T *ptr_;
  std::size_t size_;
};
 
#endif
 
class Trace;
 
class Error {
  struct deleter {
    void operator()(wasmtime_error_t *p) const { wasmtime_error_delete(p); }
  };
 
  std::unique_ptr<wasmtime_error_t, deleter> ptr;
 
public:
  Error(wasmtime_error_t *error) : ptr(error) {}
 
  std::string message() const {
    wasm_byte_vec_t msg_bytes;
    wasmtime_error_message(ptr.get(), &msg_bytes);
    auto ret = std::string(msg_bytes.data, msg_bytes.size);
    wasm_byte_vec_delete(&msg_bytes);
    return ret;
  }
 
  std::optional<int32_t> i32_exit() const {
    int32_t status = 0;
    if (wasmtime_error_exit_status(ptr.get(), &status)) {
      return status;
    }
    return std::nullopt;
  }
 
  Trace trace() const;
};
 
inline std::ostream &operator<<(std::ostream &os, const Error &e) {
  os << e.message();
  return os;
}
 
template <typename T, typename E = Error> class [[nodiscard]] Result {
  std::variant<T, E> data;
 
public:
  Result(T t) : data(std::move(t)) {}
  Result(E e) : data(std::move(e)) {}
 
  explicit operator bool() const { return data.index() == 0; }
 
  E &&err() { return std::get<E>(std::move(data)); }
  const E &&err() const { return std::get<E>(std::move(data)); }
 
  T &&ok() { return std::get<T>(std::move(data)); }
  const T &&ok() const { return std::get<T>(std::move(data)); }
 
  T unwrap() {
    if (*this) {
      return this->ok();
    }
    unwrap_failed();
  }
 
private:
  [[noreturn]] void unwrap_failed() {
    fprintf(stderr, "error: %s\n", this->err().message().c_str()); // NOLINT
    std::abort();
  }
};
 
enum class Strategy {
  Auto = WASMTIME_STRATEGY_AUTO,
  Cranelift = WASMTIME_STRATEGY_CRANELIFT,
};
 
enum class OptLevel {
  None = WASMTIME_OPT_LEVEL_NONE,
  Speed = WASMTIME_OPT_LEVEL_SPEED,
  SpeedAndSize = WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
};
 
enum class ProfilingStrategy {
  None = WASMTIME_PROFILING_STRATEGY_NONE,
  Jitdump = WASMTIME_PROFILING_STRATEGY_JITDUMP,
  Vtune = WASMTIME_PROFILING_STRATEGY_VTUNE,
};
 
class PoolAllocationConfig {
  friend class Config;
 
  struct deleter {
    void operator()(wasmtime_pooling_allocation_config_t *p) const {
      wasmtime_pooling_allocation_config_delete(p);
    }
  };
 
  std::unique_ptr<wasmtime_pooling_allocation_config_t, deleter> ptr;
 
public:
  PoolAllocationConfig() : ptr(wasmtime_pooling_allocation_config_new()) {}
 
  void max_unused_warm_slots(uint32_t max) {
    wasmtime_pooling_allocation_config_max_unused_warm_slots_set(ptr.get(),
                                                                 max);
  }
 
  void decommit_batch_size(size_t batch_size) {
    wasmtime_pooling_allocation_config_decommit_batch_size_set(ptr.get(),
                                                               batch_size);
  }
 
  void async_stack_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_async_stack_keep_resident_set(ptr.get(),
                                                                     size);
  }
 
  void linear_memory_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_linear_memory_keep_resident_set(
        ptr.get(), size);
  }
 
  void table_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_table_keep_resident_set(ptr.get(), size);
  }
 
  void total_component_instances(uint32_t count) {
    wasmtime_pooling_allocation_config_total_component_instances_set(ptr.get(),
                                                                     count);
  }
 
  void max_component_instance_size(size_t size) {
    wasmtime_pooling_allocation_config_max_component_instance_size_set(
        ptr.get(), size);
  }
 
  void max_core_instances_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_core_instances_per_component_set(
        ptr.get(), count);
  }
 
  void max_memories_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_memories_per_component_set(ptr.get(),
                                                                      count);
  }
 
  void max_tables_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_tables_per_component_set(ptr.get(),
                                                                    count);
  }
 
  void total_memories(uint32_t count) {
    wasmtime_pooling_allocation_config_total_memories_set(ptr.get(), count);
  }
 
  void total_tables(uint32_t count) {
    wasmtime_pooling_allocation_config_total_tables_set(ptr.get(), count);
  }
 
  void total_stacks(uint32_t count) {
    wasmtime_pooling_allocation_config_total_stacks_set(ptr.get(), count);
  }
 
  void total_core_instances(uint32_t count) {
    wasmtime_pooling_allocation_config_total_core_instances_set(ptr.get(),
                                                                count);
  }
 
  void max_core_instance_size(size_t size) {
    wasmtime_pooling_allocation_config_max_core_instance_size_set(ptr.get(),
                                                                  size);
  }
 
  void max_tables_per_module(uint32_t tables) {
    wasmtime_pooling_allocation_config_max_tables_per_module_set(ptr.get(),
                                                                 tables);
  }
 
  void table_elements(size_t elements) {
    wasmtime_pooling_allocation_config_table_elements_set(ptr.get(), elements);
  }
 
  void max_memories_per_module(uint32_t memories) {
    wasmtime_pooling_allocation_config_max_memories_per_module_set(ptr.get(),
                                                                   memories);
  }
 
  void max_memory_size(size_t bytes) {
    wasmtime_pooling_allocation_config_max_memory_size_set(ptr.get(), bytes);
  }
 
  void total_gc_heaps(uint32_t count) {
    wasmtime_pooling_allocation_config_total_gc_heaps_set(ptr.get(), count);
  }
};
 
class Config {
  friend class Engine;
 
  struct deleter {
    void operator()(wasm_config_t *p) const { wasm_config_delete(p); }
  };
 
  std::unique_ptr<wasm_config_t, deleter> ptr;
 
public:
  Config() : ptr(wasm_config_new()) {}
 
  void debug_info(bool enable) {
    wasmtime_config_debug_info_set(ptr.get(), enable);
  }
 
  void epoch_interruption(bool enable) {
    wasmtime_config_epoch_interruption_set(ptr.get(), enable);
  }
 
  void consume_fuel(bool enable) {
    wasmtime_config_consume_fuel_set(ptr.get(), enable);
  }
 
  void max_wasm_stack(size_t stack) {
    wasmtime_config_max_wasm_stack_set(ptr.get(), stack);
  }
 
  void wasm_threads(bool enable) {
    wasmtime_config_wasm_threads_set(ptr.get(), enable);
  }
 
  void wasm_reference_types(bool enable) {
    wasmtime_config_wasm_reference_types_set(ptr.get(), enable);
  }
 
  void wasm_simd(bool enable) {
    wasmtime_config_wasm_simd_set(ptr.get(), enable);
  }
 
  void wasm_bulk_memory(bool enable) {
    wasmtime_config_wasm_bulk_memory_set(ptr.get(), enable);
  }
 
  void wasm_multi_value(bool enable) {
    wasmtime_config_wasm_multi_value_set(ptr.get(), enable);
  }
 
  void wasm_gc(bool enable) {
    wasmtime_config_wasm_gc_set(ptr.get(), enable);
  }
 
  void wasm_function_references(bool enable) {
    wasmtime_config_wasm_function_references_set(ptr.get(), enable);
  }
 
  void parallel_compilation(bool enable) {
    wasmtime_config_parallel_compilation_set(ptr.get(), enable);
  }
 
  void strategy(Strategy strategy) {
    wasmtime_config_strategy_set(ptr.get(),
                                 static_cast<wasmtime_strategy_t>(strategy));
  }
 
  void cranelift_debug_verifier(bool enable) {
    wasmtime_config_cranelift_debug_verifier_set(ptr.get(), enable);
  }
 
  void cranelift_opt_level(OptLevel level) {
    wasmtime_config_cranelift_opt_level_set(
        ptr.get(), static_cast<wasmtime_opt_level_t>(level));
  }
 
  void profiler(ProfilingStrategy profiler) {
    wasmtime_config_profiler_set(
        ptr.get(), static_cast<wasmtime_profiling_strategy_t>(profiler));
  }
 
  void memory_reservation(size_t size) {
    wasmtime_config_memory_reservation_set(ptr.get(), size);
  }
 
  void memory_guard_size(size_t size) {
    wasmtime_config_memory_guard_size_set(ptr.get(), size);
  }
 
  Result<std::monostate> cache_load_default() {
    auto *error = wasmtime_config_cache_config_load(ptr.get(), nullptr);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  Result<std::monostate> cache_load(const std::string &path) {
    auto *error = wasmtime_config_cache_config_load(ptr.get(), path.c_str());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  void pooling_allocation_strategy(const PoolAllocationConfig &config) {
    wasmtime_pooling_allocation_strategy_set(ptr.get(), config.ptr.get());
  }
};
 
class Engine {
  friend class Store;
  friend class Module;
  friend class Linker;
 
  struct deleter {
    void operator()(wasm_engine_t *p) const { wasm_engine_delete(p); }
  };
 
  std::unique_ptr<wasm_engine_t, deleter> ptr;
 
public:
  Engine() : ptr(wasm_engine_new()) {}
  explicit Engine(Config config)
      : ptr(wasm_engine_new_with_config(config.ptr.release())) {}
 
  void increment_epoch() const { wasmtime_engine_increment_epoch(ptr.get()); }
};
 
inline Result<std::vector<uint8_t>> wat2wasm(std::string_view wat) {
  wasm_byte_vec_t ret;
  auto *error = wasmtime_wat2wasm(wat.data(), wat.size(), &ret);
  if (error != nullptr) {
    return Error(error);
  }
  std::vector<uint8_t> vec;
  // NOLINTNEXTLINE TODO can this be done without triggering lints?
  Span<uint8_t> raw(reinterpret_cast<uint8_t *>(ret.data), ret.size);
  vec.assign(raw.begin(), raw.end());
  wasm_byte_vec_delete(&ret);
  return vec;
}
 
enum class ValKind {
  I32,
  I64,
  F32,
  F64,
  V128,
  ExternRef,
  FuncRef,
};
 
#define WASMTIME_FOR_EACH_VAL_KIND(X)                                          \
  X(I32, "i32", WASM_I32)                                                      \
  X(I64, "i64", WASM_I64)                                                      \
  X(F32, "f32", WASM_F32)                                                      \
  X(F64, "f64", WASM_F64)                                                      \
  X(ExternRef, "externref", WASM_EXTERNREF)                                    \
  X(FuncRef, "funcref", WASM_FUNCREF)                                          \
  X(V128, "v128", WASMTIME_V128)
 
inline std::ostream &operator<<(std::ostream &os, const ValKind &e) {
  switch (e) {
#define CASE_KIND_PRINT_NAME(kind, name, ignore)                               \
  case ValKind::kind:                                                          \
    os << name;                                                                \
    break;
    WASMTIME_FOR_EACH_VAL_KIND(CASE_KIND_PRINT_NAME)
#undef CASE_KIND_PRINT_NAME
  default:
    abort();
  }
  return os;
}
 
class ValType {
  friend class TableType;
  friend class GlobalType;
  friend class FuncType;
 
  struct deleter {
    void operator()(wasm_valtype_t *p) const { wasm_valtype_delete(p); }
  };
 
  std::unique_ptr<wasm_valtype_t, deleter> ptr;
 
  static wasm_valkind_t kind_to_c(ValKind kind) {
    switch (kind) {
#define CASE_KIND_TO_C(kind, ignore, ckind)                                    \
  case ValKind::kind:                                                          \
    return ckind;
      WASMTIME_FOR_EACH_VAL_KIND(CASE_KIND_TO_C)
#undef CASE_KIND_TO_C
    default:
      abort();
    }
  }
 
public:
  class Ref {
    friend class ValType;
 
    const wasm_valtype_t *ptr;
 
  public:
    Ref(const wasm_valtype_t *ptr) : ptr(ptr) {}
    Ref(const ValType &ty) : Ref(ty.ptr.get()) {}
 
    ValKind kind() const {
      switch (wasm_valtype_kind(ptr)) {
#define CASE_C_TO_KIND(kind, ignore, ckind)                                    \
  case ckind:                                                                  \
    return ValKind::kind;
        WASMTIME_FOR_EACH_VAL_KIND(CASE_C_TO_KIND)
#undef CASE_C_TO_KIND
      }
      std::abort();
    }
  };
 
  class ListRef {
    const wasm_valtype_vec_t *list;
 
  public:
    ListRef(const wasm_valtype_vec_t *list) : list(list) {}
 
    typedef const Ref *iterator;
 
    iterator begin() const {
      return reinterpret_cast<Ref *>(&list->data[0]); // NOLINT
    }
 
    iterator end() const {
      return reinterpret_cast<Ref *>(&list->data[list->size]); // NOLINT
    }
 
    size_t size() const { return list->size; }
  };
 
private:
  Ref ref;
  ValType(wasm_valtype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  ValType(ValKind kind) : ValType(wasm_valtype_new(kind_to_c(kind))) {}
  ValType(Ref other) : ValType(wasm_valtype_copy(other.ptr)) {}
  ValType(const ValType &other) : ValType(wasm_valtype_copy(other.ptr.get())) {}
  ValType &operator=(const ValType &other) {
    ptr.reset(wasm_valtype_copy(other.ptr.get()));
    ref = other.ref;
    return *this;
  }
  ~ValType() = default;
  ValType(ValType &&other) = default;
  ValType &operator=(ValType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
class MemoryType {
  friend class Memory;
 
  struct deleter {
    void operator()(wasm_memorytype_t *p) const { wasm_memorytype_delete(p); }
  };
 
  std::unique_ptr<wasm_memorytype_t, deleter> ptr;
 
public:
  class Ref {
    friend class MemoryType;
 
    const wasm_memorytype_t *ptr;
 
  public:
    Ref(const wasm_memorytype_t *ptr) : ptr(ptr) {}
    Ref(const MemoryType &ty) : Ref(ty.ptr.get()) {}
 
    uint64_t min() const { return wasmtime_memorytype_minimum(ptr); }
 
    std::optional<uint64_t> max() const {
      uint64_t max = 0;
      auto present = wasmtime_memorytype_maximum(ptr, &max);
      if (present) {
        return max;
      }
      return std::nullopt;
    }
 
    bool is_64() const { return wasmtime_memorytype_is64(ptr); }
 
    bool is_shared() const { return wasmtime_memorytype_isshared(ptr); }
  };
 
private:
  Ref ref;
  MemoryType(wasm_memorytype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  explicit MemoryType(uint32_t min)
      : MemoryType(wasmtime_memorytype_new(min, false, 0, false, false)) {}
  MemoryType(uint32_t min, uint32_t max)
      : MemoryType(wasmtime_memorytype_new(min, true, max, false, false)) {}
 
  static MemoryType New64(uint64_t min) {
    return MemoryType(wasmtime_memorytype_new(min, false, 0, true, false));
  }
 
  static MemoryType New64(uint64_t min, uint64_t max) {
    return MemoryType(wasmtime_memorytype_new(min, true, max, true, false));
  }
 
  MemoryType(Ref other) : MemoryType(wasm_memorytype_copy(other.ptr)) {}
  MemoryType(const MemoryType &other)
      : MemoryType(wasm_memorytype_copy(other.ptr.get())) {}
  MemoryType &operator=(const MemoryType &other) {
    ptr.reset(wasm_memorytype_copy(other.ptr.get()));
    return *this;
  }
  ~MemoryType() = default;
  MemoryType(MemoryType &&other) = default;
  MemoryType &operator=(MemoryType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
class TableType {
  friend class Table;
 
  struct deleter {
    void operator()(wasm_tabletype_t *p) const { wasm_tabletype_delete(p); }
  };
 
  std::unique_ptr<wasm_tabletype_t, deleter> ptr;
 
public:
  class Ref {
    friend class TableType;
 
    const wasm_tabletype_t *ptr;
 
  public:
    Ref(const wasm_tabletype_t *ptr) : ptr(ptr) {}
    Ref(const TableType &ty) : Ref(ty.ptr.get()) {}
 
    uint32_t min() const { return wasm_tabletype_limits(ptr)->min; }
 
    std::optional<uint32_t> max() const {
      const auto *limits = wasm_tabletype_limits(ptr);
      if (limits->max == wasm_limits_max_default) {
        return std::nullopt;
      }
      return limits->max;
    }
 
    ValType::Ref element() const { return wasm_tabletype_element(ptr); }
  };
 
private:
  Ref ref;
  TableType(wasm_tabletype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  TableType(ValType ty, uint32_t min) : ptr(nullptr), ref(nullptr) {
    wasm_limits_t limits;
    limits.min = min;
    limits.max = wasm_limits_max_default;
    ptr.reset(wasm_tabletype_new(ty.ptr.release(), &limits));
    ref = ptr.get();
  }
  TableType(ValType ty, uint32_t min, uint32_t max) // NOLINT
      : ptr(nullptr), ref(nullptr) {
    wasm_limits_t limits;
    limits.min = min;
    limits.max = max;
    ptr.reset(wasm_tabletype_new(ty.ptr.release(), &limits));
    ref = ptr.get();
  }
  TableType(Ref other) : TableType(wasm_tabletype_copy(other.ptr)) {}
  TableType(const TableType &other)
      : TableType(wasm_tabletype_copy(other.ptr.get())) {}
  TableType &operator=(const TableType &other) {
    ptr.reset(wasm_tabletype_copy(other.ptr.get()));
    return *this;
  }
  ~TableType() = default;
  TableType(TableType &&other) = default;
  TableType &operator=(TableType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
class GlobalType {
  friend class Global;
 
  struct deleter {
    void operator()(wasm_globaltype_t *p) const { wasm_globaltype_delete(p); }
  };
 
  std::unique_ptr<wasm_globaltype_t, deleter> ptr;
 
public:
  class Ref {
    friend class GlobalType;
    const wasm_globaltype_t *ptr;
 
  public:
    Ref(const wasm_globaltype_t *ptr) : ptr(ptr) {}
    Ref(const GlobalType &ty) : Ref(ty.ptr.get()) {}
 
    bool is_mutable() const {
      return wasm_globaltype_mutability(ptr) == WASM_VAR;
    }
 
    ValType::Ref content() const { return wasm_globaltype_content(ptr); }
  };
 
private:
  Ref ref;
  GlobalType(wasm_globaltype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  GlobalType(ValType ty, bool mut)
      : GlobalType(wasm_globaltype_new(
            ty.ptr.release(),
            (wasm_mutability_t)(mut ? WASM_VAR : WASM_CONST))) {}
  GlobalType(Ref other) : GlobalType(wasm_globaltype_copy(other.ptr)) {}
  GlobalType(const GlobalType &other)
      : GlobalType(wasm_globaltype_copy(other.ptr.get())) {}
  GlobalType &operator=(const GlobalType &other) {
    ptr.reset(wasm_globaltype_copy(other.ptr.get()));
    return *this;
  }
  ~GlobalType() = default;
  GlobalType(GlobalType &&other) = default;
  GlobalType &operator=(GlobalType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
class FuncType {
  friend class Func;
  friend class Linker;
 
  struct deleter {
    void operator()(wasm_functype_t *p) const { wasm_functype_delete(p); }
  };
 
  std::unique_ptr<wasm_functype_t, deleter> ptr;
 
public:
  class Ref {
    friend class FuncType;
    const wasm_functype_t *ptr;
 
  public:
    Ref(const wasm_functype_t *ptr) : ptr(ptr) {}
    Ref(const FuncType &ty) : Ref(ty.ptr.get()) {}
 
    ValType::ListRef params() const { return wasm_functype_params(ptr); }
 
    ValType::ListRef results() const { return wasm_functype_results(ptr); }
  };
 
private:
  Ref ref;
  FuncType(wasm_functype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  FuncType(std::initializer_list<ValType> params,
           std::initializer_list<ValType> results)
      : ref(nullptr) {
    *this = FuncType::from_iters(params, results);
  }
 
  FuncType(Ref other) : FuncType(wasm_functype_copy(other.ptr)) {}
  FuncType(const FuncType &other)
      : FuncType(wasm_functype_copy(other.ptr.get())) {}
  FuncType &operator=(const FuncType &other) {
    ptr.reset(wasm_functype_copy(other.ptr.get()));
    return *this;
  }
  ~FuncType() = default;
  FuncType(FuncType &&other) = default;
  FuncType &operator=(FuncType &&other) = default;
 
  template <typename P, typename R>
  static FuncType from_iters(P params, R results) {
    wasm_valtype_vec_t param_vec;
    wasm_valtype_vec_t result_vec;
    wasm_valtype_vec_new_uninitialized(&param_vec, params.size());
    wasm_valtype_vec_new_uninitialized(&result_vec, results.size());
    size_t i = 0;
 
    for (auto val : params) {
      param_vec.data[i++] = val.ptr.release(); // NOLINT
    }
    i = 0;
    for (auto val : results) {
      result_vec.data[i++] = val.ptr.release(); // NOLINT
    }
 
    return wasm_functype_new(&param_vec, &result_vec);
  }
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
class ImportType {
public:
  class Ref {
    friend class ExternType;
 
    const wasm_importtype_t *ptr;
 
    // TODO: can this circle be broken another way?
    const wasm_externtype_t *raw_type() { return wasm_importtype_type(ptr); }
 
  public:
    Ref(const wasm_importtype_t *ptr) : ptr(ptr) {}
 
    std::string_view module() {
      const auto *name = wasm_importtype_module(ptr);
      return std::string_view(name->data, name->size);
    }
 
    std::string_view name() {
      const auto *name = wasm_importtype_name(ptr);
      return std::string_view(name->data, name->size);
    }
  };
 
  class List {
    friend class Module;
    wasm_importtype_vec_t list;
 
  public:
    List() : list{} {
      list.size = 0;
      list.data = nullptr;
    }
    List(const List &other) = delete;
    List(List &&other) noexcept : list(other.list) { other.list.size = 0; }
    ~List() {
      if (list.size > 0) {
        wasm_importtype_vec_delete(&list);
      }
    }
 
    List &operator=(const List &other) = delete;
    List &operator=(List &&other) noexcept {
      std::swap(list, other.list);
      return *this;
    }
 
    typedef const Ref *iterator;
    iterator begin() const {
      return reinterpret_cast<iterator>(&list.data[0]); // NOLINT
    }
    iterator end() const {
      return reinterpret_cast<iterator>(&list.data[list.size]); // NOLINT
    }
    size_t size() const { return list.size; }
  };
};
 
class ExportType {
 
public:
  class Ref {
    friend class ExternType;
 
    const wasm_exporttype_t *ptr;
 
    const wasm_externtype_t *raw_type() { return wasm_exporttype_type(ptr); }
 
  public:
    Ref(const wasm_exporttype_t *ptr) : ptr(ptr) {}
 
    std::string_view name() {
      const auto *name = wasm_exporttype_name(ptr);
      return std::string_view(name->data, name->size);
    }
  };
 
  class List {
    friend class Module;
    wasm_exporttype_vec_t list;
 
  public:
    List() : list{} {
      list.size = 0;
      list.data = nullptr;
    }
    List(const List &other) = delete;
    List(List &&other) noexcept : list(other.list) { other.list.size = 0; }
    ~List() {
      if (list.size > 0) {
        wasm_exporttype_vec_delete(&list);
      }
    }
 
    List &operator=(const List &other) = delete;
    List &operator=(List &&other) noexcept {
      std::swap(list, other.list);
      return *this;
    }
 
    typedef const Ref *iterator;
    iterator begin() const {
      return reinterpret_cast<iterator>(&list.data[0]); // NOLINT
    }
    iterator end() const {
      return reinterpret_cast<iterator>(&list.data[list.size]); // NOLINT
    }
    size_t size() const { return list.size; }
  };
};
 
class ExternType {
  friend class ExportType;
  friend class ImportType;
 
public:
  typedef std::variant<FuncType::Ref, GlobalType::Ref, TableType::Ref,
                       MemoryType::Ref>
      Ref;
 
  static Ref from_import(ImportType::Ref ty) {
    // TODO: this would ideally be some sort of implicit constructor, unsure how
    // to do that though...
    return ref_from_c(ty.raw_type());
  }
 
  static Ref from_export(ExportType::Ref ty) {
    // TODO: this would ideally be some sort of implicit constructor, unsure how
    // to do that though...
    return ref_from_c(ty.raw_type());
  }
 
private:
  static Ref ref_from_c(const wasm_externtype_t *ptr) {
    switch (wasm_externtype_kind(ptr)) {
    case WASM_EXTERN_FUNC:
      return wasm_externtype_as_functype_const(ptr);
    case WASM_EXTERN_GLOBAL:
      return wasm_externtype_as_globaltype_const(ptr);
    case WASM_EXTERN_TABLE:
      return wasm_externtype_as_tabletype_const(ptr);
    case WASM_EXTERN_MEMORY:
      return wasm_externtype_as_memorytype_const(ptr);
    }
    std::abort();
  }
};
 
class FrameRef {
  wasm_frame_t *frame;
 
public:
  uint32_t func_index() const { return wasm_frame_func_index(frame); }
  size_t func_offset() const { return wasm_frame_func_offset(frame); }
  size_t module_offset() const { return wasm_frame_module_offset(frame); }
 
  std::optional<std::string_view> func_name() const {
    const auto *name = wasmtime_frame_func_name(frame);
    if (name != nullptr) {
      return std::string_view(name->data, name->size);
    }
    return std::nullopt;
  }
 
  std::optional<std::string_view> module_name() const {
    const auto *name = wasmtime_frame_module_name(frame);
    if (name != nullptr) {
      return std::string_view(name->data, name->size);
    }
    return std::nullopt;
  }
};
 
class Trace {
  friend class Trap;
  friend class Error;
 
  wasm_frame_vec_t vec;
 
  Trace(wasm_frame_vec_t vec) : vec(vec) {}
 
public:
  ~Trace() { wasm_frame_vec_delete(&vec); }
 
  Trace(const Trace &other) = delete;
  Trace(Trace &&other) = delete;
  Trace &operator=(const Trace &other) = delete;
  Trace &operator=(Trace &&other) = delete;
 
  typedef const FrameRef *iterator;
 
  iterator begin() const {
    return reinterpret_cast<FrameRef *>(&vec.data[0]); // NOLINT
  }
  iterator end() const {
    return reinterpret_cast<FrameRef *>(&vec.data[vec.size]); // NOLINT
  }
  size_t size() const { return vec.size; }
};
 
inline Trace Error::trace() const {
  wasm_frame_vec_t frames;
  wasmtime_error_wasm_trace(ptr.get(), &frames);
  return Trace(frames);
}
 
class Trap {
  friend class Linker;
  friend class Instance;
  friend class Func;
  template <typename Params, typename Results> friend class TypedFunc;
 
  struct deleter {
    void operator()(wasm_trap_t *p) const { wasm_trap_delete(p); }
  };
 
  std::unique_ptr<wasm_trap_t, deleter> ptr;
 
  Trap(wasm_trap_t *ptr) : ptr(ptr) {}
 
public:
  explicit Trap(std::string_view msg)
      : Trap(wasmtime_trap_new(msg.data(), msg.size())) {}
 
  std::string message() const {
    wasm_byte_vec_t msg;
    wasm_trap_message(ptr.get(), &msg);
    std::string ret(msg.data, msg.size - 1);
    wasm_byte_vec_delete(&msg);
    return ret;
  }
 
  Trace trace() const {
    wasm_frame_vec_t frames;
    wasm_trap_trace(ptr.get(), &frames);
    return Trace(frames);
  }
};
 
struct TrapError {
  std::variant<Trap, Error> data;
 
  TrapError(Trap t) : data(std::move(t)) {}
  TrapError(Error e) : data(std::move(e)) {}
 
  std::string message() const {
    if (const auto *trap = std::get_if<Trap>(&data)) {
      return trap->message();
    }
    if (const auto *error = std::get_if<Error>(&data)) {
      return std::string(error->message());
    }
    std::abort();
  }
};
 
template <typename T> using TrapResult = Result<T, TrapError>;
 
class Module {
  friend class Store;
  friend class Instance;
  friend class Linker;
 
  struct deleter {
    void operator()(wasmtime_module_t *p) const { wasmtime_module_delete(p); }
  };
 
  std::unique_ptr<wasmtime_module_t, deleter> ptr;
 
  Module(wasmtime_module_t *raw) : ptr(raw) {}
 
public:
  Module(const Module &other) : ptr(wasmtime_module_clone(other.ptr.get())) {}
  Module &operator=(const Module &other) {
    ptr.reset(wasmtime_module_clone(other.ptr.get()));
    return *this;
  }
  ~Module() = default;
  Module(Module &&other) = default;
  Module &operator=(Module &&other) = default;
 
  static Result<Module> compile(Engine &engine, std::string_view wat) {
    auto wasm = wat2wasm(wat);
    if (!wasm) {
      return wasm.err();
    }
    auto bytes = wasm.ok();
    return compile(engine, bytes);
  }
 
  static Result<Module> compile(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_module_t *ret = nullptr;
    auto *error =
        wasmtime_module_new(engine.ptr.get(), wasm.data(), wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  static Result<std::monostate> validate(Engine &engine, Span<uint8_t> wasm) {
    auto *error =
        wasmtime_module_validate(engine.ptr.get(), wasm.data(), wasm.size());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  static Result<Module> deserialize(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_module_t *ret = nullptr;
    auto *error = wasmtime_module_deserialize(engine.ptr.get(), wasm.data(),
                                              wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  static Result<Module> deserialize_file(Engine &engine,
                                         const std::string &path) {
    wasmtime_module_t *ret = nullptr;
    auto *error =
        wasmtime_module_deserialize_file(engine.ptr.get(), path.c_str(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Module(ret);
  }
 
  ImportType::List imports() const {
    ImportType::List list;
    wasmtime_module_imports(ptr.get(), &list.list);
    return list;
  }
 
  ExportType::List exports() const {
    ExportType::List list;
    wasmtime_module_exports(ptr.get(), &list.list);
    return list;
  }
 
  Result<std::vector<uint8_t>> serialize() const {
    wasm_byte_vec_t bytes;
    auto *error = wasmtime_module_serialize(ptr.get(), &bytes);
    if (error != nullptr) {
      return Error(error);
    }
    std::vector<uint8_t> ret;
    // NOLINTNEXTLINE TODO can this be done without triggering lints?
    Span<uint8_t> raw(reinterpret_cast<uint8_t *>(bytes.data), bytes.size);
    ret.assign(raw.begin(), raw.end());
    wasm_byte_vec_delete(&bytes);
    return ret;
  }
};
 
class WasiConfig {
  friend class Store;
 
  struct deleter {
    void operator()(wasi_config_t *p) const { wasi_config_delete(p); }
  };
 
  std::unique_ptr<wasi_config_t, deleter> ptr;
 
public:
  WasiConfig() : ptr(wasi_config_new()) {}
 
  void argv(const std::vector<std::string> &args) {
    std::vector<const char *> ptrs;
    ptrs.reserve(args.size());
    for (const auto &arg : args) {
      ptrs.push_back(arg.c_str());
    }
 
    wasi_config_set_argv(ptr.get(), (int)args.size(), ptrs.data());
  }
 
  void inherit_argv() { wasi_config_inherit_argv(ptr.get()); }
 
  void env(const std::vector<std::pair<std::string, std::string>> &env) {
    std::vector<const char *> names;
    std::vector<const char *> values;
    for (const auto &[name, value] : env) {
      names.push_back(name.c_str());
      values.push_back(value.c_str());
    }
    wasi_config_set_env(ptr.get(), (int)env.size(), names.data(),
                        values.data());
  }
 
  void inherit_env() { wasi_config_inherit_env(ptr.get()); }
 
  [[nodiscard]] bool stdin_file(const std::string &path) {
    return wasi_config_set_stdin_file(ptr.get(), path.c_str());
  }
 
  void inherit_stdin() { return wasi_config_inherit_stdin(ptr.get()); }
 
  [[nodiscard]] bool stdout_file(const std::string &path) {
    return wasi_config_set_stdout_file(ptr.get(), path.c_str());
  }
 
  void inherit_stdout() { return wasi_config_inherit_stdout(ptr.get()); }
 
  [[nodiscard]] bool stderr_file(const std::string &path) {
    return wasi_config_set_stderr_file(ptr.get(), path.c_str());
  }
 
  void inherit_stderr() { return wasi_config_inherit_stderr(ptr.get()); }
 
  [[nodiscard]] bool preopen_dir(const std::string &path,
                                 const std::string &guest_path,
                                 size_t dir_perms,
                                 size_t file_perms) {
    return wasi_config_preopen_dir(ptr.get(), path.c_str(), guest_path.c_str(), dir_perms, file_perms);
  }
};
 
class Caller;
template <typename Params, typename Results> class TypedFunc;
 
class Store {
  struct deleter {
    void operator()(wasmtime_store_t *p) const { wasmtime_store_delete(p); }
  };
 
  std::unique_ptr<wasmtime_store_t, deleter> ptr;
 
  static void finalizer(void *ptr) {
    std::unique_ptr<std::any> _ptr(static_cast<std::any *>(ptr));
  }
 
public:
  explicit Store(Engine &engine)
      : ptr(wasmtime_store_new(engine.ptr.get(), nullptr, finalizer)) {}
 
  class Context {
    friend class Global;
    friend class Table;
    friend class Memory;
    friend class Func;
    friend class Instance;
    friend class Linker;
    friend class ExternRef;
    friend class Val;
    wasmtime_context_t *ptr;
 
    Context(wasmtime_context_t *ptr) : ptr(ptr) {}
 
  public:
    Context(Store &store) : Context(wasmtime_store_context(store.ptr.get())) {}
    Context(Store *store) : Context(*store) {}
    Context(Caller &caller);
    Context(Caller *caller);
 
    void gc() { wasmtime_context_gc(ptr); }
 
    Result<std::monostate> set_fuel(uint64_t fuel) {
      auto *error = wasmtime_context_set_fuel(ptr, fuel);
      if (error != nullptr) {
        return Error(error);
      }
      return std::monostate();
    }
 
    Result<uint64_t> get_fuel() const {
      uint64_t fuel = 0;
      auto *error = wasmtime_context_get_fuel(ptr, &fuel);
      if (error != nullptr) {
        return Error(error);
      }
      return fuel;
    }
 
    void set_data(std::any data) const {
      finalizer(static_cast<std::any *>(wasmtime_context_get_data(ptr)));
      wasmtime_context_set_data(
          ptr, std::make_unique<std::any>(std::move(data)).release());
    }
 
    std::any &get_data() const {
      return *static_cast<std::any *>(wasmtime_context_get_data(ptr));
    }
 
    Result<std::monostate> set_wasi(WasiConfig config) {
      auto *error = wasmtime_context_set_wasi(ptr, config.ptr.release());
      if (error != nullptr) {
        return Error(error);
      }
      return std::monostate();
    }
 
    void set_epoch_deadline(uint64_t ticks_beyond_current) {
      wasmtime_context_set_epoch_deadline(ptr, ticks_beyond_current);
    }
 
    wasmtime_context_t *raw_context() { return ptr; }
  };
 
  void limiter(int64_t memory_size, int64_t table_elements, int64_t instances,
               int64_t tables, int64_t memories) {
    wasmtime_store_limiter(ptr.get(), memory_size, table_elements, instances,
                           tables, memories);
  }
 
  Context context() { return this; }
};
 
class ExternRef {
  friend class Val;
 
  wasmtime_externref_t val;
 
  static void finalizer(void *ptr) {
    std::unique_ptr<std::any> _ptr(static_cast<std::any *>(ptr));
  }
 
public:
  explicit ExternRef(wasmtime_externref_t val) : val(val) {}
 
  template <typename T> explicit ExternRef(Store::Context cx, T val) {
    void *ptr = std::make_unique<std::any>(std::move(val)).release();
    bool ok = wasmtime_externref_new(cx.ptr, ptr, finalizer, &this->val);
    if (!ok)  {
      fprintf(stderr, "failed to allocate a new externref");
      abort();
    }
  }
 
  ExternRef clone(Store::Context cx) {
    wasmtime_externref_t other;
    wasmtime_externref_clone(cx.ptr, &val, &other);
    return ExternRef(other);
  }
 
  std::any &data(Store::Context cx) {
    return *static_cast<std::any *>(wasmtime_externref_data(cx.ptr, &val));
  }
 
  void unroot(Store::Context cx) {
    wasmtime_externref_unroot(cx.ptr, &val);
  }
 
  const wasmtime_externref_t *raw() const { return &val; }
};
 
class Func;
class Global;
class Instance;
class Memory;
class Table;
 
typedef std::variant<Func, Global, Memory, Table> Extern;
 
struct V128 {
  wasmtime_v128 v128;
 
  V128() : v128{} { memset(&v128[0], 0, sizeof(wasmtime_v128)); }
 
  V128(const wasmtime_v128 &v) : v128{} {
    memcpy(&v128[0], &v[0], sizeof(wasmtime_v128));
  }
};
 
class Val {
  friend class Global;
  friend class Table;
  friend class Func;
 
  wasmtime_val_t val;
 
  Val() : val{} {
    val.kind = WASMTIME_I32;
    val.of.i32 = 0;
  }
  Val(wasmtime_val_t val) : val(val) {}
 
public:
  Val(int32_t i32) : val{} {
    val.kind = WASMTIME_I32;
    val.of.i32 = i32;
  }
  Val(int64_t i64) : val{} {
    val.kind = WASMTIME_I64;
    val.of.i64 = i64;
  }
  Val(float f32) : val{} {
    val.kind = WASMTIME_F32;
    val.of.f32 = f32;
  }
  Val(double f64) : val{} {
    val.kind = WASMTIME_F64;
    val.of.f64 = f64;
  }
  Val(const V128 &v128) : val{} {
    val.kind = WASMTIME_V128;
    memcpy(&val.of.v128[0], &v128.v128[0], sizeof(wasmtime_v128));
  }
  Val(std::optional<Func> func);
  Val(Func func);
  Val(std::optional<ExternRef> ptr) : val{} {
    val.kind = WASMTIME_EXTERNREF;
    if (ptr) {
      val.of.externref = ptr->val;
    } else {
      wasmtime_externref_set_null(&val.of.externref);
    }
  }
  Val(ExternRef ptr);
 
  ValKind kind() const {
    switch (val.kind) {
    case WASMTIME_I32:
      return ValKind::I32;
    case WASMTIME_I64:
      return ValKind::I64;
    case WASMTIME_F32:
      return ValKind::F32;
    case WASMTIME_F64:
      return ValKind::F64;
    case WASMTIME_FUNCREF:
      return ValKind::FuncRef;
    case WASMTIME_EXTERNREF:
      return ValKind::ExternRef;
    case WASMTIME_V128:
      return ValKind::V128;
    }
    std::abort();
  }
 
  int32_t i32() const {
    if (val.kind != WASMTIME_I32) {
      std::abort();
    }
    return val.of.i32;
  }
 
  int64_t i64() const {
    if (val.kind != WASMTIME_I64) {
      std::abort();
    }
    return val.of.i64;
  }
 
  float f32() const {
    if (val.kind != WASMTIME_F32) {
      std::abort();
    }
    return val.of.f32;
  }
 
  double f64() const {
    if (val.kind != WASMTIME_F64) {
      std::abort();
    }
    return val.of.f64;
  }
 
  V128 v128() const {
    if (val.kind != WASMTIME_V128) {
      std::abort();
    }
    return val.of.v128;
  }
 
  std::optional<ExternRef> externref(Store::Context cx) const {
    if (val.kind != WASMTIME_EXTERNREF) {
      std::abort();
    }
    if (val.of.externref.store_id == 0) {
      return std::nullopt;
    }
    wasmtime_externref_t other;
    wasmtime_externref_clone(cx.ptr, &val.of.externref, &other);
    return ExternRef(other);
  }
 
  std::optional<Func> funcref() const;
 
  void unroot(Store::Context cx) {
    wasmtime_val_unroot(cx.ptr, &val);
  }
};
 
class Caller {
  friend class Func;
  friend class Store;
  wasmtime_caller_t *ptr;
  Caller(wasmtime_caller_t *ptr) : ptr(ptr) {}
 
public:
  std::optional<Extern> get_export(std::string_view name);
 
  Store::Context context() { return this; }
};
 
inline Store::Context::Context(Caller &caller)
    : Context(wasmtime_caller_context(caller.ptr)) {}
inline Store::Context::Context(Caller *caller) : Context(*caller) {}
 
namespace detail {
 
template <typename T> struct WasmType { static const bool valid = false; };
 
// NOLINTNEXTLINE
#define NATIVE_WASM_TYPE(native, valkind, field)                               \
  template <> struct WasmType<native> {                                        \
    static const bool valid = true;                                            \
    static const ValKind kind = ValKind::valkind;                              \
    static void store(Store::Context cx, wasmtime_val_raw_t *p,                \
                      const native &t) {                                       \
      p->field = t;                                                            \
    }                                                                          \
    static native load(Store::Context cx, wasmtime_val_raw_t *p) {             \
      return p->field;                                                         \
    }                                                                          \
  };
 
NATIVE_WASM_TYPE(int32_t, I32, i32)
NATIVE_WASM_TYPE(uint32_t, I32, i32)
NATIVE_WASM_TYPE(int64_t, I64, i64)
NATIVE_WASM_TYPE(uint64_t, I64, i64)
NATIVE_WASM_TYPE(float, F32, f32)
NATIVE_WASM_TYPE(double, F64, f64)
 
#undef NATIVE_WASM_TYPE
 
template <> struct WasmType<std::optional<ExternRef>> {
  static const bool valid = true;
  static const ValKind kind = ValKind::ExternRef;
  static void store(Store::Context cx, wasmtime_val_raw_t *p,
                    const std::optional<ExternRef> &ref) {
    if (ref) {
      p->externref = wasmtime_externref_to_raw(cx.raw_context(), ref->raw());
    } else {
      p->externref = 0;
    }
  }
  static std::optional<ExternRef> load(Store::Context cx,
                                       wasmtime_val_raw_t *p) {
    if (p->externref == 0) {
      return std::nullopt;
    }
    wasmtime_externref_t val;
    wasmtime_externref_from_raw(cx.raw_context(), p->externref, &val);
    return ExternRef(val);
  }
};
 
template <> struct WasmType<V128> {
  static const bool valid = true;
  static const ValKind kind = ValKind::V128;
  static void store(Store::Context cx, wasmtime_val_raw_t *p, const V128 &t) {
    memcpy(&p->v128[0], &t.v128[0], sizeof(wasmtime_v128));
  }
  static V128 load(Store::Context cx, wasmtime_val_raw_t *p) { return p->v128; }
};
 
template <typename T> struct WasmTypeList {
  static const bool valid = WasmType<T>::valid;
  static const size_t size = 1;
  static bool matches(ValType::ListRef types) {
    return WasmTypeList<std::tuple<T>>::matches(types);
  }
  static void store(Store::Context cx, wasmtime_val_raw_t *storage,
                    const T &t) {
    WasmType<T>::store(cx, storage, t);
  }
  static T load(Store::Context cx, wasmtime_val_raw_t *storage) {
    return WasmType<T>::load(cx, storage);
  }
  static std::vector<ValType> types() { return {WasmType<T>::kind}; }
};
 
template <> struct WasmTypeList<std::monostate> {
  static const bool valid = true;
  static const size_t size = 0;
  static bool matches(ValType::ListRef types) { return types.size() == 0; }
  static void store(Store::Context cx, wasmtime_val_raw_t *storage,
                    const std::monostate &t) {}
  static std::monostate load(Store::Context cx, wasmtime_val_raw_t *storage) {
    return std::monostate();
  }
  static std::vector<ValType> types() { return {}; }
};
 
template <typename... T> struct WasmTypeList<std::tuple<T...>> {
  static const bool valid = (WasmType<T>::valid && ...);
  static const size_t size = sizeof...(T);
  static bool matches(ValType::ListRef types) {
    if (types.size() != size) {
      return false;
    }
    size_t n = 0;
    return ((WasmType<T>::kind == types.begin()[n++].kind()) && ...);
  }
  static void store(Store::Context cx, wasmtime_val_raw_t *storage,
                    const std::tuple<T...> &t) {
    size_t n = 0;
    std::apply(
        [&](const auto &...val) {
          (WasmType<T>::store(cx, &storage[n++], val), ...); // NOLINT
        },
        t);
  }
  static std::tuple<T...> load(Store::Context cx, wasmtime_val_raw_t *storage) {
    size_t n = 0;
    return std::tuple<T...>{WasmType<T>::load(cx, &storage[n++])...}; // NOLINT
  }
  static std::vector<ValType> types() { return {WasmType<T>::kind...}; }
};
 
template <typename R> struct WasmHostRet {
  using Results = WasmTypeList<R>;
 
  template <typename F, typename... A>
  static std::optional<Trap> invoke(F f, Caller cx, wasmtime_val_raw_t *raw,
                                    A... args) {
    auto ret = f(args...);
    Results::store(cx, raw, ret);
    return std::nullopt;
  }
};
 
template <> struct WasmHostRet<void> {
  using Results = WasmTypeList<std::tuple<>>;
 
  template <typename F, typename... A>
  static std::optional<Trap> invoke(F f, Caller cx, wasmtime_val_raw_t *raw,
                                    A... args) {
    f(args...);
    return std::nullopt;
  }
};
 
// Alternative method of returning "nothing" (also enables `std::monostate` in
// the `R` type of `Result` below)
template <> struct WasmHostRet<std::monostate> : public WasmHostRet<void> {};
 
template <typename R> struct WasmHostRet<Result<R, Trap>> {
  using Results = WasmTypeList<R>;
 
  template <typename F, typename... A>
  static std::optional<Trap> invoke(F f, Caller cx, wasmtime_val_raw_t *raw,
                                    A... args) {
    Result<R, Trap> ret = f(args...);
    if (!ret) {
      return ret.err();
    }
    Results::store(cx, raw, ret.ok());
    return std::nullopt;
  }
};
 
template <typename F, typename = void> struct WasmHostFunc;
 
template <typename R, typename... A> struct WasmHostFunc<R (*)(A...)> {
  using Params = WasmTypeList<std::tuple<A...>>;
  using Results = typename WasmHostRet<R>::Results;
 
  template <typename F>
  static std::optional<Trap> invoke(F &f, Caller cx, wasmtime_val_raw_t *raw) {
    auto params = Params::load(cx, raw);
    return std::apply(
        [&](const auto &...val) {
          return WasmHostRet<R>::invoke(f, cx, raw, val...);
        },
        params);
  }
};
 
template <typename R, typename... A>
struct WasmHostFunc<R (*)(Caller, A...)> : public WasmHostFunc<R (*)(A...)> {
  // Override `invoke` here to pass the `cx` as the first parameter
  template <typename F>
  static std::optional<Trap> invoke(F &f, Caller cx, wasmtime_val_raw_t *raw) {
    auto params = WasmTypeList<std::tuple<A...>>::load(cx, raw);
    return std::apply(
        [&](const auto &...val) {
          return WasmHostRet<R>::invoke(f, cx, raw, cx, val...);
        },
        params);
  }
};
 
template <typename R, typename C, typename... A>
struct WasmHostFunc<R (C::*)(A...)> : public WasmHostFunc<R (*)(A...)> {};
 
template <typename R, typename C, typename... A>
struct WasmHostFunc<R (C::*)(A...) const> : public WasmHostFunc<R (*)(A...)> {};
 
template <typename R, typename C, typename... A>
struct WasmHostFunc<R (C::*)(Caller, A...)>
    : public WasmHostFunc<R (*)(Caller, A...)> {};
 
template <typename R, typename C, typename... A>
struct WasmHostFunc<R (C::*)(Caller, A...) const>
    : public WasmHostFunc<R (*)(Caller, A...)> {};
 
template <typename T>
struct WasmHostFunc<T, std::void_t<decltype(&T::operator())>>
    : public WasmHostFunc<decltype(&T::operator())> {};
 
} // namespace detail
 
using namespace detail;
 
class Func {
  friend class Val;
  friend class Instance;
  friend class Linker;
  template <typename Params, typename Results> friend class TypedFunc;
 
  wasmtime_func_t func;
 
  template <typename F>
  static wasm_trap_t *raw_callback(void *env, wasmtime_caller_t *caller,
                                   const wasmtime_val_t *args, size_t nargs,
                                   wasmtime_val_t *results, size_t nresults) {
    static_assert(alignof(Val) == alignof(wasmtime_val_t));
    static_assert(sizeof(Val) == sizeof(wasmtime_val_t));
    F *func = reinterpret_cast<F *>(env);                          // NOLINT
    Span<const Val> args_span(reinterpret_cast<const Val *>(args), // NOLINT
                              nargs);
    Span<Val> results_span(reinterpret_cast<Val *>(results), // NOLINT
                           nresults);
    Result<std::monostate, Trap> result =
        (*func)(Caller(caller), args_span, results_span);
    if (!result) {
      return result.err().ptr.release();
    }
    return nullptr;
  }
 
  template <typename F>
  static wasm_trap_t *
  raw_callback_unchecked(void *env, wasmtime_caller_t *caller,
                         wasmtime_val_raw_t *args_and_results,
                         size_t nargs_and_results) {
    using HostFunc = WasmHostFunc<F>;
    Caller cx(caller);
    F *func = reinterpret_cast<F *>(env); // NOLINT
    auto trap = HostFunc::invoke(*func, cx, args_and_results);
    if (trap) {
      return trap->ptr.release();
    }
    return nullptr;
  }
 
  template <typename F> static void raw_finalize(void *env) {
    std::unique_ptr<F> ptr(reinterpret_cast<F *>(env)); // NOLINT
  }
 
public:
  Func(wasmtime_func_t func) : func(func) {}
 
  template <typename F,
            std::enable_if_t<
                std::is_invocable_r_v<Result<std::monostate, Trap>, F, Caller,
                                      Span<const Val>, Span<Val>>,
                bool> = true>
  Func(Store::Context cx, const FuncType &ty, F f) : func({}) {
    wasmtime_func_new(cx.ptr, ty.ptr.get(), raw_callback<F>,
                      std::make_unique<F>(f).release(), raw_finalize<F>, &func);
  }
 
  template <typename F,
            std::enable_if_t<WasmHostFunc<F>::Params::valid, bool> = true,
            std::enable_if_t<WasmHostFunc<F>::Results::valid, bool> = true>
  static Func wrap(Store::Context cx, F f) {
    using HostFunc = WasmHostFunc<F>;
    auto params = HostFunc::Params::types();
    auto results = HostFunc::Results::types();
    auto ty = FuncType::from_iters(params, results);
    wasmtime_func_t func;
    wasmtime_func_new_unchecked(cx.ptr, ty.ptr.get(), raw_callback_unchecked<F>,
                                std::make_unique<F>(f).release(),
                                raw_finalize<F>, &func);
    return func;
  }
 
  template <typename I>
  TrapResult<std::vector<Val>> call(Store::Context cx, const I &begin,
                                    const I &end) const {
    std::vector<wasmtime_val_t> raw_params;
    raw_params.reserve(end - begin);
    for (auto i = begin; i != end; i++) {
      raw_params.push_back(i->val);
    }
    size_t nresults = this->type(cx)->results().size();
    std::vector<wasmtime_val_t> raw_results(nresults);
 
    wasm_trap_t *trap = nullptr;
    auto *error =
        wasmtime_func_call(cx.ptr, &func, raw_params.data(), raw_params.size(),
                           raw_results.data(), raw_results.capacity(), &trap);
    if (error != nullptr) {
      return TrapError(Error(error));
    }
    if (trap != nullptr) {
      return TrapError(Trap(trap));
    }
 
    std::vector<Val> results;
    results.reserve(nresults);
    for (size_t i = 0; i < nresults; i++) {
      results.push_back(raw_results[i]);
    }
    return results;
  }
 
  TrapResult<std::vector<Val>> call(Store::Context cx,
                                    const std::vector<Val> &params) const {
    return this->call(cx, params.begin(), params.end());
  }
 
  TrapResult<std::vector<Val>>
  call(Store::Context cx, const std::initializer_list<Val> &params) const {
    return this->call(cx, params.begin(), params.end());
  }
 
  FuncType type(Store::Context cx) const {
    return wasmtime_func_type(cx.ptr, &func);
  }
 
  template <typename Params, typename Results,
            std::enable_if_t<WasmTypeList<Params>::valid, bool> = true,
            std::enable_if_t<WasmTypeList<Results>::valid, bool> = true>
  Result<TypedFunc<Params, Results>, Trap> typed(Store::Context cx) const {
    auto ty = this->type(cx);
    if (!WasmTypeList<Params>::matches(ty->params()) ||
        !WasmTypeList<Results>::matches(ty->results())) {
      return Trap("static type for this function does not match actual type");
    }
    TypedFunc<Params, Results> ret(*this);
    return ret;
  }
 
  const wasmtime_func_t &raw_func() const { return func; }
};
 
template <typename Params, typename Results> class TypedFunc {
  friend class Func;
  Func f;
  TypedFunc(Func func) : f(func) {}
 
public:
  TrapResult<Results> call(Store::Context cx, Params params) const {
    std::array<wasmtime_val_raw_t, std::max(WasmTypeList<Params>::size,
                                            WasmTypeList<Results>::size)>
        storage;
    wasmtime_val_raw_t *ptr = storage.data();
    if (ptr == nullptr)
      ptr = reinterpret_cast<wasmtime_val_raw_t*>(alignof(wasmtime_val_raw_t));
    WasmTypeList<Params>::store(cx, ptr, params);
    wasm_trap_t *trap = nullptr;
    auto *error = wasmtime_func_call_unchecked(
        cx.raw_context(), &f.func, ptr, storage.size(), &trap);
    if (error != nullptr) {
      return TrapError(Error(error));
    }
    if (trap != nullptr) {
      return TrapError(Trap(trap));
    }
    return WasmTypeList<Results>::load(cx, ptr);
  }
 
  const Func &func() const { return f; }
};
 
inline Val::Val(std::optional<Func> func) : val{} {
  val.kind = WASMTIME_FUNCREF;
  if (func) {
    val.of.funcref = (*func).func;
  } else {
    wasmtime_funcref_set_null(&val.of.funcref);
  }
}
 
inline Val::Val(Func func) : Val(std::optional(func)) {}
inline Val::Val(ExternRef ptr) : Val(std::optional(ptr)) {}
 
inline std::optional<Func> Val::funcref() const {
  if (val.kind != WASMTIME_FUNCREF) {
    std::abort();
  }
  if (val.of.funcref.store_id == 0) {
    return std::nullopt;
  }
  return Func(val.of.funcref);
}
 
template <> struct detail::WasmType<std::optional<Func>> {
  static const bool valid = true;
  static const ValKind kind = ValKind::FuncRef;
  static void store(Store::Context cx, wasmtime_val_raw_t *p,
                    const std::optional<Func> func) {
    if (func) {
      p->funcref = wasmtime_func_to_raw(cx.raw_context(), &func->raw_func());
    } else {
      p->funcref = 0;
    }
  }
  static std::optional<Func> load(Store::Context cx, wasmtime_val_raw_t *p) {
    if (p->funcref == 0) {
      return std::nullopt;
    }
    wasmtime_func_t ret;
    wasmtime_func_from_raw(cx.raw_context(), p->funcref, &ret);
    return ret;
  }
};
 
class Global {
  friend class Instance;
  wasmtime_global_t global;
 
public:
  Global(wasmtime_global_t global) : global(global) {}
 
  static Result<Global> create(Store::Context cx, const GlobalType &ty,
                               const Val &init) {
    wasmtime_global_t global;
    auto *error = wasmtime_global_new(cx.ptr, ty.ptr.get(), &init.val, &global);
    if (error != nullptr) {
      return Error(error);
    }
    return Global(global);
  }
 
  GlobalType type(Store::Context cx) const {
    return wasmtime_global_type(cx.ptr, &global);
  }
 
  Val get(Store::Context cx) const;
 
  Result<std::monostate> set(Store::Context cx, const Val &val) const {
    auto *error = wasmtime_global_set(cx.ptr, &global, &val.val);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
};
 
class Table {
  friend class Instance;
  wasmtime_table_t table;
 
public:
  Table(wasmtime_table_t table) : table(table) {}
 
  static Result<Table> create(Store::Context cx, const TableType &ty,
                              const Val &init) {
    wasmtime_table_t table;
    auto *error = wasmtime_table_new(cx.ptr, ty.ptr.get(), &init.val, &table);
    if (error != nullptr) {
      return Error(error);
    }
    return Table(table);
  }
 
  TableType type(Store::Context cx) const {
    return wasmtime_table_type(cx.ptr, &table);
  }
 
  uint64_t size(Store::Context cx) const {
    return wasmtime_table_size(cx.ptr, &table);
  }
 
  std::optional<Val> get(Store::Context cx, uint64_t idx) const {
    Val val;
    if (wasmtime_table_get(cx.ptr, &table, idx, &val.val)) {
      return val;
    }
    return std::nullopt;
  }
 
  Result<std::monostate> set(Store::Context cx, uint64_t idx,
                             const Val &val) const {
    auto *error = wasmtime_table_set(cx.ptr, &table, idx, &val.val);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  Result<uint64_t> grow(Store::Context cx, uint64_t delta,
                        const Val &init) const {
    uint64_t prev = 0;
    auto *error = wasmtime_table_grow(cx.ptr, &table, delta, &init.val, &prev);
    if (error != nullptr) {
      return Error(error);
    }
    return prev;
  }
};
 
// gcc 8.3.0 seems to require that this comes after the definition of `Table`. I
// don't know why...
inline Val Global::get(Store::Context cx) const {
  Val val;
  wasmtime_global_get(cx.ptr, &global, &val.val);
  return val;
}
 
class Memory {
  friend class Instance;
  wasmtime_memory_t memory;
 
public:
  Memory(wasmtime_memory_t memory) : memory(memory) {}
 
  static Result<Memory> create(Store::Context cx, const MemoryType &ty) {
    wasmtime_memory_t memory;
    auto *error = wasmtime_memory_new(cx.ptr, ty.ptr.get(), &memory);
    if (error != nullptr) {
      return Error(error);
    }
    return Memory(memory);
  }
 
  MemoryType type(Store::Context cx) const {
    return wasmtime_memory_type(cx.ptr, &memory);
  }
 
  uint64_t size(Store::Context cx) const {
    return wasmtime_memory_size(cx.ptr, &memory);
  }
 
  Span<uint8_t> data(Store::Context cx) const {
    auto *base = wasmtime_memory_data(cx.ptr, &memory);
    auto size = wasmtime_memory_data_size(cx.ptr, &memory);
    return {base, size};
  }
 
  Result<uint64_t> grow(Store::Context cx, uint64_t delta) const {
    uint64_t prev = 0;
    auto *error = wasmtime_memory_grow(cx.ptr, &memory, delta, &prev);
    if (error != nullptr) {
      return Error(error);
    }
    return prev;
  }
};
 
class Instance {
  friend class Linker;
  friend class Caller;
 
  wasmtime_instance_t instance;
 
  static Extern cvt(wasmtime_extern_t &e) {
    switch (e.kind) {
    case WASMTIME_EXTERN_FUNC:
      return Func(e.of.func);
    case WASMTIME_EXTERN_GLOBAL:
      return Global(e.of.global);
    case WASMTIME_EXTERN_MEMORY:
      return Memory(e.of.memory);
    case WASMTIME_EXTERN_TABLE:
      return Table(e.of.table);
    }
    std::abort();
  }
 
  static void cvt(const Extern &e, wasmtime_extern_t &raw) {
    if (const auto *func = std::get_if<Func>(&e)) {
      raw.kind = WASMTIME_EXTERN_FUNC;
      raw.of.func = func->func;
    } else if (const auto *global = std::get_if<Global>(&e)) {
      raw.kind = WASMTIME_EXTERN_GLOBAL;
      raw.of.global = global->global;
    } else if (const auto *table = std::get_if<Table>(&e)) {
      raw.kind = WASMTIME_EXTERN_TABLE;
      raw.of.table = table->table;
    } else if (const auto *memory = std::get_if<Memory>(&e)) {
      raw.kind = WASMTIME_EXTERN_MEMORY;
      raw.of.memory = memory->memory;
    } else {
      std::abort();
    }
  }
 
public:
  Instance(wasmtime_instance_t instance) : instance(instance) {}
 
  static TrapResult<Instance> create(Store::Context cx, const Module &m,
                                     const std::vector<Extern> &imports) {
    std::vector<wasmtime_extern_t> raw_imports;
    for (const auto &item : imports) {
      raw_imports.push_back(wasmtime_extern_t{});
      auto &last = raw_imports.back();
      Instance::cvt(item, last);
    }
    wasmtime_instance_t instance;
    wasm_trap_t *trap = nullptr;
    auto *error = wasmtime_instance_new(cx.ptr, m.ptr.get(), raw_imports.data(),
                                        raw_imports.size(), &instance, &trap);
    if (error != nullptr) {
      return TrapError(Error(error));
    }
    if (trap != nullptr) {
      return TrapError(Trap(trap));
    }
    return Instance(instance);
  }
 
  std::optional<Extern> get(Store::Context cx, std::string_view name) {
    wasmtime_extern_t e;
    if (!wasmtime_instance_export_get(cx.ptr, &instance, name.data(),
                                      name.size(), &e)) {
      return std::nullopt;
    }
    return Instance::cvt(e);
  }
 
  std::optional<std::pair<std::string_view, Extern>> get(Store::Context cx,
                                                         size_t idx) {
    wasmtime_extern_t e;
    // I'm not sure why clang-tidy thinks this is using va_list or anything
    // related to that...
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
    char *name = nullptr;
    size_t len = 0;
    if (!wasmtime_instance_export_nth(cx.ptr, &instance, idx, &name, &len,
                                      &e)) {
      return std::nullopt;
    }
    std::string_view n(name, len);
    return std::pair(n, Instance::cvt(e));
  }
};
 
inline std::optional<Extern> Caller::get_export(std::string_view name) {
  wasmtime_extern_t item;
  if (wasmtime_caller_export_get(ptr, name.data(), name.size(), &item)) {
    return Instance::cvt(item);
  }
  return std::nullopt;
}
 
class Linker {
  struct deleter {
    void operator()(wasmtime_linker_t *p) const { wasmtime_linker_delete(p); }
  };
 
  std::unique_ptr<wasmtime_linker_t, deleter> ptr;
 
public:
  explicit Linker(Engine &engine)
      : ptr(wasmtime_linker_new(engine.ptr.get())) {}
 
  void allow_shadowing(bool allow) {
    wasmtime_linker_allow_shadowing(ptr.get(), allow);
  }
 
  Result<std::monostate> define(Store::Context cx, std::string_view module,
                                std::string_view name, const Extern &item) {
    wasmtime_extern_t raw;
    Instance::cvt(item, raw);
    auto *error =
        wasmtime_linker_define(ptr.get(), cx.ptr, module.data(), module.size(),
                               name.data(), name.size(), &raw);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  Result<std::monostate> define_wasi() {
    auto *error = wasmtime_linker_define_wasi(ptr.get());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  Result<std::monostate>
  define_instance(Store::Context cx, std::string_view name, Instance instance) {
    auto *error = wasmtime_linker_define_instance(
        ptr.get(), cx.ptr, name.data(), name.size(), &instance.instance);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  TrapResult<Instance> instantiate(Store::Context cx, const Module &m) {
    wasmtime_instance_t instance;
    wasm_trap_t *trap = nullptr;
    auto *error = wasmtime_linker_instantiate(ptr.get(), cx.ptr, m.ptr.get(),
                                              &instance, &trap);
    if (error != nullptr) {
      return TrapError(Error(error));
    }
    if (trap != nullptr) {
      return TrapError(Trap(trap));
    }
    return Instance(instance);
  }
 
  Result<std::monostate> module(Store::Context cx, std::string_view name,
                                const Module &m) {
    auto *error = wasmtime_linker_module(ptr.get(), cx.ptr, name.data(),
                                         name.size(), m.ptr.get());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  [[nodiscard]] std::optional<Extern>
  get(Store::Context cx, std::string_view module, std::string_view name) {
    wasmtime_extern_t item;
    if (wasmtime_linker_get(ptr.get(), cx.ptr, module.data(), module.size(),
                            name.data(), name.size(), &item)) {
      return Instance::cvt(item);
    }
    return std::nullopt;
  }
 
  template <typename F,
            std::enable_if_t<
                std::is_invocable_r_v<Result<std::monostate, Trap>, F, Caller,
                                      Span<const Val>, Span<Val>>,
                bool> = true>
  Result<std::monostate> func_new(std::string_view module,
                                  std::string_view name, const FuncType &ty,
                                  F&& f) {
 
    auto *error = wasmtime_linker_define_func(
        ptr.get(), module.data(), module.length(), name.data(), name.length(),
        ty.ptr.get(), Func::raw_callback<std::remove_reference_t<F>>, std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f)).release(),
        Func::raw_finalize<std::remove_reference_t<F>>);
 
    if (error != nullptr) {
      return Error(error);
    }
 
    return std::monostate();
  }
 
  template <typename F,
            std::enable_if_t<WasmHostFunc<F>::Params::valid, bool> = true,
            std::enable_if_t<WasmHostFunc<F>::Results::valid, bool> = true>
  Result<std::monostate> func_wrap(std::string_view module,
                                   std::string_view name, F&& f) {
    using HostFunc = WasmHostFunc<F>;
    auto params = HostFunc::Params::types();
    auto results = HostFunc::Results::types();
    auto ty = FuncType::from_iters(params, results);
    auto *error = wasmtime_linker_define_func_unchecked(
        ptr.get(), module.data(), module.length(), name.data(), name.length(),
        ty.ptr.get(), Func::raw_callback_unchecked<std::remove_reference_t<F>>,
        std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f)).release(), Func::raw_finalize<std::remove_reference_t<F>>);
 
    if (error != nullptr) {
      return Error(error);
    }
 
    return std::monostate();
  }
 
  Result<Func> get_default(Store::Context cx, std::string_view name) {
    wasmtime_func_t item;
    auto *error = wasmtime_linker_get_default(ptr.get(), cx.ptr, name.data(),
                                              name.size(), &item);
    if (error != nullptr) {
      return Error(error);
    }
    return Func(item);
  }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_HH