refactor: link type information at runtime (#377)

Co-authored-by: Bas Zalmstra <zalmstra.bas@gmail.com>

Author: Wodann

.clang-format

@@ -1,3 +1,5 @@
 BasedOnStyle: Google
 IndentWidth: 4
+IndentAccessModifiers: false
+AccessModifierOffset: -4
 ColumnLimit: 100

c/include/mun/abi.h

@@ -42,6 +42,66 @@ typedef struct MunGuid {
     uint8_t _0[16];
 } MunGuid;
 
+/**
+ * Represents a unique identifier for types. The runtime can use this to lookup the corresponding [`TypeInfo`].
+ */
+typedef struct MunTypeId {
+    /**
+     * The GUID of the type
+     */
+    struct MunGuid guid;
+} MunTypeId;
+
+/**
+ * Represents a function signature.
+ */
+typedef struct MunFunctionSignature {
+    /**
+     * Argument types
+     */
+    const struct MunTypeId *arg_types;
+    /**
+     * Optional return type
+     */
+    struct MunTypeId return_type;
+    /**
+     * Number of argument types
+     */
+    uint16_t num_arg_types;
+} MunFunctionSignature;
+
+/**
+ * Represents a function prototype. A function prototype contains the name, type signature, but
+ * not an implementation.
+ */
+typedef struct MunFunctionPrototype {
+    /**
+     * Function name
+     */
+    const char *name;
+    /**
+     * The type signature of the function
+     */
+    struct MunFunctionSignature signature;
+} MunFunctionPrototype;
+
+/**
+ * Represents a function definition. A function definition contains the name, type signature, and
+ * a pointer to the implementation.
+ *
+ * `fn_ptr` can be used to call the declared function.
+ */
+typedef struct MunFunctionDefinition {
+    /**
+     * Function prototype
+     */
+    struct MunFunctionPrototype prototype;
+    /**
+     * Function pointer
+     */
+    const void *fn_ptr;
+} MunFunctionDefinition;
+
 /**
  * Represents a struct declaration.
  */
@@ -53,7 +113,7 @@ typedef struct MunStructInfo {
     /**
      * Struct fields' information
      */
-    const struct MunTypeInfo *const *field_types;
+    const struct MunTypeId *field_types;
     /**
      * Struct fields' offsets
      */
@@ -105,9 +165,9 @@ typedef union MunTypeInfoData {
  */
 typedef struct MunTypeInfo {
     /**
-     * Type GUID
+     * Type ID
      */
-    struct MunGuid guid;
+    struct MunTypeId id;
     /**
      * Type name
      */
@@ -126,56 +186,6 @@ typedef struct MunTypeInfo {
     union MunTypeInfoData data;
 } MunTypeInfo;
 
-/**
- * Represents a function signature.
- */
-typedef struct MunFunctionSignature {
-    /**
-     * Argument types
-     */
-    const struct MunTypeInfo *const *arg_types;
-    /**
-     * Optional return type
-     */
-    const struct MunTypeInfo *return_type;
-    /**
-     * Number of argument types
-     */
-    uint16_t num_arg_types;
-} MunFunctionSignature;
-
-/**
- * Represents a function prototype. A function prototype contains the name, type signature, but
- * not an implementation.
- */
-typedef struct MunFunctionPrototype {
-    /**
-     * Function name
-     */
-    const char *name;
-    /**
-     * The type signature of the function
-     */
-    struct MunFunctionSignature signature;
-} MunFunctionPrototype;
-
-/**
- * Represents a function definition. A function definition contains the name, type signature, and
- * a pointer to the implementation.
- *
- * `fn_ptr` can be used to call the declared function.
- */
-typedef struct MunFunctionDefinition {
-    /**
-     * Function prototype
-     */
-    struct MunFunctionPrototype prototype;
-    /**
-     * Function pointer
-     */
-    const void *fn_ptr;
-} MunFunctionDefinition;
-
 /**
  * Represents a module declaration.
  */
@@ -191,7 +201,7 @@ typedef struct MunModuleInfo {
     /**
      * Module types
      */
-    const struct MunTypeInfo *const *types;
+    const struct MunTypeInfo *types;
     /**
      * Number of module functions
      */
@@ -222,6 +232,30 @@ typedef struct MunDispatchTable {
     uint32_t num_entries;
 } MunDispatchTable;
 
+/**
+ * Represents a lookup table for type information. This is used for runtime linking.
+ *
+ * Type IDs and handles are stored separately for cache efficiency.
+ */
+typedef struct MunTypeLut {
+    /**
+     * Type IDs
+     */
+    const struct MunTypeId *type_ids;
+    /**
+     * Type information handles
+     */
+    const void **type_handles;
+    /**
+     * Debug names
+     */
+    const char *const *type_names;
+    /**
+     * Number of types
+     */
+    uint32_t num_entries;
+} MunTypeLut;
+
 /**
  * Represents an assembly declaration.
  */
@@ -231,9 +265,13 @@ typedef struct MunAssemblyInfo {
      */
     struct MunModuleInfo symbols;
     /**
-     * Dispatch table
+     * Function dispatch table
      */
     struct MunDispatchTable dispatch_table;
+    /**
+     * Type lookup table
+     */
+    struct MunTypeLut type_lut;
     /**
      * Paths to assembly dependencies
      */

cpp/include/mun/error.h

@@ -9,9 +9,9 @@ namespace mun {
  * Frees the corresponding error object on destruction, if it exists.
  */
 class Error {
-   public:
+public:
     /** Default constructs an error. */
-    Error() noexcept : m_handle{0} {}
+    Error() noexcept : m_handle{nullptr} {}
 
     /** Constructs an error from a `MunErrorHandle`.
      *
@@ -23,31 +23,31 @@ class Error {
      *
      * \param other an rvalue reference to an error
      */
-    Error(Error&& other) noexcept : m_handle(other.m_handle) { other.m_handle._0 = 0; }
+    Error(Error&& other) noexcept : m_handle(other.m_handle) { other.m_handle._0 = nullptr; }
 
     /** Move assigns an error.
      *
      * \param other an rvalue reference to an error
      */
     Error& operator=(Error&& other) noexcept {
         m_handle = other.m_handle;
-        other.m_handle._0 = 0;
+        other.m_handle._0 = nullptr;
         return *this;
     }
 
     /** Destructs the error. */
     ~Error() noexcept { mun_error_destroy(m_handle); }
 
-    /** Retrieves the error message, if it exists, otherwise returns a nullptr.
+    /** Returns the error message, if it exists, otherwise returns a nullptr.
      *
      * The message is UTF-8 encoded.
      */
-    const char* message() noexcept { return mun_error_message(m_handle); }
+    const char* message() noexcept { return m_handle._0; }
 
-    /** Retrieves whether an error exists */
-    operator bool() const noexcept { return m_handle._0 != 0; }
+    /** Retrieves whether an error occurred */
+    operator bool() const noexcept { return m_handle._0 != nullptr; }
 
-   private:
+private:
     MunErrorHandle m_handle;
 };
 }  // namespace mun

cpp/include/mun/field_info.h

@@ -0,0 +1,92 @@
+#ifndef MUN_FIELD_INFO_H_
+#define MUN_FIELD_INFO_H_
+
+#include <cassert>
+
+#include "mun/runtime_capi.h"
+#include "mun/type_info.h"
+
+namespace mun {
+/**
+ * @brief A wrapper around a Mun field information handle.
+ */
+class FieldInfo {
+public:
+    /**
+     * @brief Constructs field information from an instantiated `MunFieldInfoHandle`.
+     */
+    FieldInfo(MunFieldInfoHandle handle) noexcept : m_handle(handle) {}
+
+    /**
+     * @brief Retrieves the field's name.
+     */
+    std::string_view name() const noexcept {
+        const auto ptr = mun_field_info_name(m_handle);
+        assert(ptr);
+        return ptr;
+    }
+
+    /**
+     * @brief Retrieves the field's type.
+     */
+    TypeInfo type() const noexcept {
+        const auto type_handle = mun_field_info_type(m_handle);
+        assert(type_handle._0);
+        return TypeInfo(type_handle);
+    }
+
+    /**
+     * @brief Retrieves the field's offset.
+     */
+    uint16_t offset() const noexcept {
+        uint16_t offset;
+        const auto error_handle = mun_field_info_offset(m_handle, &offset);
+        assert(error_handle._0 == nullptr);
+        return offset;
+    }
+
+private:
+    MunFieldInfoHandle m_handle;
+};
+
+/**
+ * @brief A wrapper around a span of Mun field informations, which are owned by the Mun runtime.
+ */
+class FieldInfoSpan {
+public:
+    /**
+     * @brief Constructs a field information span from an instantiated `MunFieldInfoSpan`.
+     */
+    FieldInfoSpan(MunFieldInfoSpan span) noexcept : m_span(span) {}
+
+    FieldInfoSpan(FieldInfoSpan&&) = default;
+    FieldInfoSpan(const FieldInfoSpan&) = delete;
+
+    ~FieldInfoSpan() noexcept { mun_field_info_span_destroy(m_span); }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     */
+    const MunFieldInfoHandle* begin() const noexcept { return data(); }
+
+    /**
+     * @brief Returns an iterator to the end.
+     */
+    const MunFieldInfoHandle* end() const noexcept { return data() + size() + 1; }
+
+    /**
+     * @brief Returns a pointer to the beginning of the sequence of elements.
+     */
+    const MunFieldInfoHandle* data() const noexcept { return m_span.data; }
+
+    /**
+     * @brief Returns the number of elements in the sequence.
+     */
+    size_t size() const noexcept { return m_span.len; }
+
+private:
+    MunFieldInfoSpan m_span;
+};
+}  // namespace mun
+
+#endif  // MUN_FIELD_INFO_H_