feat(cpp): Import Mode (#5)

This feature simplifies C++ library integration of MLC by avoiding
double registration.

**What is and when double registration happens**. Originally, macro
`MLC_DEF_{DYN/STATIC}_TYPE` and `MLC_DEF_OBJ_REF` registers an MLC
object's type key and reflection information into the global type table,
and those macros are idiomatically used in public header files. It
means, if there's a different DLL that includes MLC headers, the
registration of MLC objects will be performed again at loading time of
this DLL.

**Implication of double registration**. Double registration is
practically harmless in most of the cases, as long as libraries are not
dynamically unloaded, and in our case, ABI issue is carefully avoided.
However, it may take a significant hit in compilation time and is not
usually best practice for potential ABI issues.

**Solution**. This PR introduces a new parameter `IS_EXPORT` to the
three macros above, as part of the practice where we define macros like
`MLC_EXPORTS` already in C++. When it is set to `False`, all the
registrations are skipped and the macros instead look up the type table
for already-existed information.

Note that while setting `IS_EXPORT` can be tedious, it could be resolved
by wrapping it with a simpler macro:

```C++
// Step 1. Check `MY_LIB_EXPORTS`
#ifndef MY_LIB_EXPORTS
#define MY_LIB_EXPORTS 0
#else
#undef MY_LIB_EXPORTS
#define MY_LIB_EXPORTS 1
#endif

// Step 2. Wrap `MLC_*` macros using new macros
#define MY_LIB_DEF_OBJ(A, B, C) \
        MLC_DEF_DYN_TYPE(MY_LIB_EXPORTS, A, B, C)
#define MY_LIB_DEF_OBJ_REF(A, B, C) \
        MLC_DEF_OBJ_REF(MY_LIB_EXPORTS, A, B, C)
```

This PR also refactors the existing approach accessing `libmlc.so`,
limiting the access to MLC C APIs via `mlc::Lib` defined in `lib.h`,
which exposes a global MLC type table handle as an inline static member.

Author: potatomashed

cmake/Utils/Library.cmake

@@ -1,12 +1,13 @@
 function(add_target_from_obj target_name obj_target_name)
   add_library(${target_name}_static STATIC $<TARGET_OBJECTS:${obj_target_name}>)
+  target_compile_definitions(${obj_target_name} PRIVATE MLC_EXPORTS)
   set_target_properties(
     ${target_name}_static PROPERTIES
     OUTPUT_NAME "${target_name}_static"
     PREFIX "lib"
     ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
     LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
-    )
+  )
   add_library(${target_name}_shared SHARED $<TARGET_OBJECTS:${obj_target_name}>)
   set_target_properties(
     ${target_name}_shared PROPERTIES
@@ -18,7 +19,6 @@ function(add_target_from_obj target_name obj_target_name)
   add_custom_target(${target_name})
   add_dependencies(${target_name} ${target_name}_static ${target_name}_shared)
   if (MSVC)
-    target_compile_definitions(${obj_target_name} PRIVATE MLC_EXPORTS)
     set_target_properties(
       ${obj_target_name} ${target_name}_shared ${target_name}_static
       PROPERTIES

cpp/c_api.cc

@@ -185,3 +185,9 @@ MLC_API void MLCExtObjDelete(void *objptr) {
     std::abort();
   }
 }
+
+MLC_API int32_t MLCHandleGetGlobal(MLCTypeTableHandle *self) {
+  MLC_SAFE_CALL_BEGIN();
+  *self = TypeTable::Global();
+  MLC_SAFE_CALL_END(&last_error);
+}

cpp/c_api_tests.cc

@@ -79,11 +79,11 @@ struct TestingCClassObj : public Object {
 
   int64_t i64_plus_one() const { return i64 + 1; }
 
-  MLC_DEF_DYN_TYPE(TestingCClassObj, Object, "mlc.testing.c_class");
+  MLC_DEF_DYN_TYPE(MLC_EXPORTS, TestingCClassObj, Object, "mlc.testing.c_class");
 };
 
 struct TestingCClass : public ObjectRef {
-  MLC_DEF_OBJ_REF(TestingCClass, TestingCClassObj, ObjectRef)
+  MLC_DEF_OBJ_REF(MLC_EXPORTS, TestingCClass, TestingCClassObj, ObjectRef)
       .Field("i8", &TestingCClassObj::i8)
       .Field("i16", &TestingCClassObj::i16)
       .Field("i32", &TestingCClassObj::i32)

cpp/json.cc

@@ -84,7 +84,7 @@ inline mlc::Str Serialize(Any any) {
       } else if (type_index >= kMLCStaticObjectBegin) {
         EmitObject(any->operator Object *());
       } else {
-        MLC_THROW(TypeError) << "Cannot serialize type: " << ::mlc::base::TypeIndex2TypeKey(type_index);
+        MLC_THROW(TypeError) << "Cannot serialize type: " << Lib::GetTypeKey(type_index);
       }
     }
     inline void EmitObject(Object *obj) {
@@ -160,7 +160,7 @@ inline mlc::Str Serialize(Any any) {
     DLDataType v = any;
     os << "[" << type_dtype << ", \"" << TypeTraits<DLDataType>::__str__(v) << "\"]";
   } else {
-    MLC_THROW(TypeError) << "Cannot serialize type: " << mlc::base::TypeIndex2TypeKey(any.type_index);
+    MLC_THROW(TypeError) << "Cannot serialize type: " << Lib::GetTypeKey(any.type_index);
   }
   os << "], \"type_keys\": [";
   for (size_t i = 0; i < type_keys.size(); ++i) {
@@ -174,16 +174,15 @@ inline mlc::Str Serialize(Any any) {
 }
 
 inline Any Deserialize(const char *json_str, int64_t json_str_len) {
-  MLCVTableHandle init_table = ::mlc::base::LibState::init;
   // Step 0. Parse JSON string
   UDict json_obj = JSONLoads(json_str, json_str_len);
   // Step 1. type_key => constructors
   UList type_keys = json_obj->at("type_keys");
   std::vector<FuncObj *> constructors;
   constructors.reserve(type_keys.size());
   for (Str type_key : type_keys) {
-    int32_t type_index = ::mlc::base::TypeKey2TypeIndex(type_key->data());
-    FuncObj *func = ::mlc::base::LibState::VTableGetFunc(init_table, type_index, "__init__");
+    int32_t type_index = Lib::GetTypeIndex(type_key->data());
+    FuncObj *func = Lib::_init(type_index);
     constructors.push_back(func);
   }
   auto invoke_init = [&constructors](UList args) {

cpp/registry.h

@@ -379,8 +379,7 @@ struct TypeTable {
   }
 
   void AddMethod(int32_t type_index, MLCTypeMethod method) {
-    // TODO: check `override_mode`
-    this->GetGlobalVTable(method.name)->Set(type_index, reinterpret_cast<FuncObj *>(method.func), 0);
+    this->GetGlobalVTable(method.name)->Set(type_index, reinterpret_cast<FuncObj *>(method.func), 2);
     this->GetTypeInfoWrapper(type_index)->AddMethod(method);
   }
 
@@ -395,39 +394,39 @@ struct TypeTable {
 
 struct _POD_REG {
   inline static const int32_t _none = //
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCNone))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCNone))
           .MemFn("__str__", &::mlc::base::TypeTraits<std::nullptr_t>::__str__);
   inline static const int32_t _int = //
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCInt))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCInt))
           .StaticFn("__init__", [](AnyView value) { return value.operator int64_t(); })
           .StaticFn("__new_ref__",
                     [](void *dst, Optional<int64_t> value) { *reinterpret_cast<Optional<int64_t> *>(dst) = value; })
           .MemFn("__str__", &::mlc::base::TypeTraits<int64_t>::__str__);
   inline static const int32_t _float =
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCFloat))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCFloat))
           .StaticFn("__new_ref__",
                     [](void *dst, Optional<double> value) { *reinterpret_cast<Optional<double> *>(dst) = value; })
           .MemFn("__str__", &::mlc::base::TypeTraits<double>::__str__);
   inline static const int32_t _ptr =
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCPtr))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCPtr))
           .StaticFn("__new_ref__",
                     [](void *dst, Optional<void *> value) { *reinterpret_cast<Optional<void *> *>(dst) = value; })
           .MemFn("__str__", &::mlc::base::TypeTraits<void *>::__str__);
   inline static const int32_t _device =
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCDevice))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCDevice))
           .StaticFn("__init__", [](AnyView device) { return device.operator DLDevice(); })
           .StaticFn("__new_ref__",
                     [](void *dst, Optional<DLDevice> value) { *reinterpret_cast<Optional<DLDevice> *>(dst) = value; })
           .MemFn("__str__", &::mlc::base::TypeTraits<DLDevice>::__str__);
   inline static const int32_t _dtype =
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCDataType))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCDataType))
           .StaticFn("__init__", [](AnyView dtype) { return dtype.operator DLDataType(); })
           .StaticFn(
               "__new_ref__",
               [](void *dst, Optional<DLDataType> value) { *reinterpret_cast<Optional<DLDataType> *>(dst) = value; })
           .MemFn("__str__", &::mlc::base::TypeTraits<DLDataType>::__str__);
   inline static const int32_t _str = //
-      ::mlc::core::ReflectionHelper(static_cast<int32_t>(MLCTypeIndex::kMLCRawStr))
+      ::mlc::core::_Reflect(static_cast<int32_t>(MLCTypeIndex::kMLCRawStr))
           .MemFn("__str__", &::mlc::base::TypeTraits<const char *>::__str__);
 };
 
@@ -463,7 +462,6 @@ inline void VTable::Set(int32_t type_index, FuncObj *func, int32_t override_mode
       // Allow override
       this->type_table->pool.DelObj(it->second);
     } else if (override_mode == 2) {
-      // TODO: throw exception
       MLCTypeInfo *type_info = this->type_table->GetTypeInfo(type_index);
       if (type_info && !name.empty()) {
         MLC_THROW(KeyError) << "VTable `" << name << "` already registered for type: " << type_info->type_key;

cpp/structure.cc

@@ -152,8 +152,7 @@ inline void StructuralEqualImpl(Object *lhs, Object *rhs, bool bind_free_vars) {
       int32_t lhs_type_index = lhs ? lhs->GetTypeIndex() : kMLCNone;
       int32_t rhs_type_index = rhs ? rhs->GetTypeIndex() : kMLCNone;
       if (lhs_type_index != rhs_type_index) {
-        MLC_CORE_EQ_S_ERR(::mlc::base::TypeIndex2TypeKey(lhs_type_index),
-                          ::mlc::base::TypeIndex2TypeKey(rhs_type_index), new_path);
+        MLC_CORE_EQ_S_ERR(Lib::GetTypeKey(lhs_type_index), Lib::GetTypeKey(rhs_type_index), new_path);
       } else if (lhs_type_index == kMLCStr) {
         Str lhs_str(reinterpret_cast<StrObj *>(lhs));
         Str rhs_str(reinterpret_cast<StrObj *>(rhs));
@@ -164,7 +163,7 @@ inline void StructuralEqualImpl(Object *lhs, Object *rhs, bool bind_free_vars) {
         throw SEqualError("Cannot compare `mlc.Func` or `mlc.Error`", new_path);
       } else {
         bool visited = false;
-        MLCTypeInfo *type_info = ::mlc::base::TypeIndex2TypeInfo(lhs_type_index);
+        MLCTypeInfo *type_info = Lib::GetTypeInfo(lhs_type_index);
         tasks->push_back(Task{lhs, rhs, type_info, visited, bind_free_vars, new_path, nullptr});
       }
     }
@@ -301,14 +300,14 @@ inline void StructuralEqualImpl(Object *lhs, Object *rhs, bool bind_free_vars) {
 
 struct HashCache {
   inline static const uint64_t MLC_SYMBOL_HIDE kNoneCombined =
-      ::mlc::base::HashCombine(::mlc::base::TypeIndex2TypeInfo(kMLCNone)->type_key_hash, 0);
-  inline static const uint64_t MLC_SYMBOL_HIDE kInt = ::mlc::base::TypeIndex2TypeInfo(kMLCInt)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kFloat = ::mlc::base::TypeIndex2TypeInfo(kMLCFloat)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kPtr = ::mlc::base::TypeIndex2TypeInfo(kMLCPtr)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kDType = ::mlc::base::TypeIndex2TypeInfo(kMLCDataType)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kDevice = ::mlc::base::TypeIndex2TypeInfo(kMLCDevice)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kRawStr = ::mlc::base::TypeIndex2TypeInfo(kMLCRawStr)->type_key_hash;
-  inline static const uint64_t MLC_SYMBOL_HIDE kStrObj = ::mlc::base::TypeIndex2TypeInfo(kMLCStr)->type_key_hash;
+      ::mlc::base::HashCombine(Lib::GetTypeInfo(kMLCNone)->type_key_hash, 0);
+  inline static const uint64_t MLC_SYMBOL_HIDE kInt = Lib::GetTypeInfo(kMLCInt)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kFloat = Lib::GetTypeInfo(kMLCFloat)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kPtr = Lib::GetTypeInfo(kMLCPtr)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kDType = Lib::GetTypeInfo(kMLCDataType)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kDevice = Lib::GetTypeInfo(kMLCDevice)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kRawStr = Lib::GetTypeInfo(kMLCRawStr)->type_key_hash;
+  inline static const uint64_t MLC_SYMBOL_HIDE kStrObj = Lib::GetTypeInfo(kMLCStr)->type_key_hash;
   inline static const uint64_t MLC_SYMBOL_HIDE kBound = ::mlc::base::StrHash("$$Bounds$$");
   inline static const uint64_t MLC_SYMBOL_HIDE kUnbound = ::mlc::base::StrHash("$$Unbound$$");
 };
@@ -399,7 +398,7 @@ inline uint64_t StructuralHash(Object *obj) {
       } else if (type_index == kMLCFunc || type_index == kMLCError) {
         throw SEqualError("Cannot compare `mlc.Func` or `mlc.Error`", ObjectPath::Root());
       } else {
-        MLCTypeInfo *type_info = ::mlc::base::TypeIndex2TypeInfo(type_index);
+        MLCTypeInfo *type_info = Lib::GetTypeInfo(type_index);
         tasks->emplace_back(Task{obj, type_info, false, bind_free_vars, type_info->type_key_hash});
       }
     }
@@ -565,8 +564,8 @@ inline Any CopyShallow(AnyView source) {
     MLC_INLINE void operator()(MLCTypeField *, const char **v) { fields->push_back(AnyView(*v)); }
     std::vector<AnyView> *fields;
   };
-  FuncObj *init_func = ::mlc::base::LibState::VTableGetFunc(::mlc::base::LibState::init, type_index, "__init__");
-  MLCTypeInfo *type_info = ::mlc::base::TypeIndex2TypeInfo(type_index);
+  FuncObj *init_func = Lib::_init(type_index);
+  MLCTypeInfo *type_info = Lib::GetTypeInfo(type_index);
   std::vector<AnyView> fields;
   VisitFields(source.operator Object *(), type_info, Copier{&fields});
   Any ret;
@@ -652,9 +651,8 @@ inline Any CopyDeep(AnyView source) {
     } else {
       fields.clear();
       VisitFields(object, type_info, Copier{&orig2copy, &fields});
-      FuncObj *func =
-          ::mlc::base::LibState::VTableGetFunc(::mlc::base::LibState::init, type_info->type_index, "__init__");
-      ::mlc::base::FuncCall(func, static_cast<int32_t>(fields.size()), fields.data(), &ret);
+      FuncObj *init_func = Lib::_init(type_info->type_index);
+      ::mlc::base::FuncCall(init_func, static_cast<int32_t>(fields.size()), fields.data(), &ret);
     }
     orig2copy[object] = ret.operator ObjectRef();
   });

include/mlc/base/all.h

@@ -4,6 +4,7 @@
 #include "./alloc.h"         // IWYU pragma: export
 #include "./any.h"           // IWYU pragma: export
 #include "./base_traits.h"   // IWYU pragma: export
+#include "./lib.h"           // IWYU pragma: export
 #include "./optional.h"      // IWYU pragma: export
 #include "./ref.h"           // IWYU pragma: export
 #include "./traits_device.h" // IWYU pragma: export

include/mlc/base/any.h

@@ -1,6 +1,7 @@
 #ifndef MLC_BASE_ANY_H_
 #define MLC_BASE_ANY_H_
 #include "./base_traits.h"
+#include "./lib.h"
 #include "./utils.h"
 #include <cstring>
 #include <type_traits>
@@ -72,20 +73,20 @@ struct AnyView : public MLCAny {
   }
   template <typename DerivedObj> inline DerivedObj *Cast() {
     if (!this->IsInstance<DerivedObj>()) {
-      MLC_THROW(TypeError) << "Cannot cast from type `" << ::mlc::base::TypeIndex2TypeKey(this->type_index)
-                           << "` to type `" << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
+      MLC_THROW(TypeError) << "Cannot cast from type `" << Lib::GetTypeKey(this->type_index) << "` to type `"
+                           << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
     }
     return reinterpret_cast<DerivedObj *>(this->v.v_obj);
   }
   template <typename DerivedObj> MLC_INLINE const DerivedObj *Cast() const {
     if (!this->IsInstance<DerivedObj>()) {
-      MLC_THROW(TypeError) << "Cannot cast from type `" << ::mlc::base::TypeIndex2TypeKey(this->type_index)
-                           << "` to type `" << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
+      MLC_THROW(TypeError) << "Cannot cast from type `" << Lib::GetTypeKey(this->type_index) << "` to type `"
+                           << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
     }
     return reinterpret_cast<const DerivedObj *>(this->v.v_obj);
   }
   int32_t GetTypeIndex() const { return this->type_index; }
-  const char *GetTypeKey() const { return ::mlc::base::TypeIndex2TypeInfo(this->type_index)->type_key; }
+  const char *GetTypeKey() const { return Lib::GetTypeKey(this->type_index); }
 
   template <typename T, typename = std::enable_if_t<::mlc::base::Anyable<::mlc::base::RemoveCR<T>>>>
   MLC_INLINE_NO_MSVC T _CastWithStorage(Any *storage) const; // TODO: reemove this
@@ -166,20 +167,20 @@ struct Any : public MLCAny {
   }
   template <typename DerivedObj> inline DerivedObj *Cast() {
     if (!this->IsInstance<DerivedObj>()) {
-      MLC_THROW(TypeError) << "Cannot cast from type `" << ::mlc::base::TypeIndex2TypeKey(this->type_index)
-                           << "` to type `" << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
+      MLC_THROW(TypeError) << "Cannot cast from type `" << Lib::GetTypeKey(this->type_index) << "` to type `"
+                           << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
     }
     return reinterpret_cast<DerivedObj *>(this->v.v_obj);
   }
   template <typename DerivedObj> MLC_INLINE const DerivedObj *Cast() const {
     if (!this->IsInstance<DerivedObj>()) {
-      MLC_THROW(TypeError) << "Cannot cast from type `" << ::mlc::base::TypeIndex2TypeKey(this->type_index)
-                           << "` to type `" << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
+      MLC_THROW(TypeError) << "Cannot cast from type `" << Lib::GetTypeKey(this->type_index) << "` to type `"
+                           << ::mlc::base::Type2Str<DerivedObj>::Run() << "`";
     }
     return reinterpret_cast<const DerivedObj *>(this->v.v_obj);
   }
   int32_t GetTypeIndex() const { return this->type_index; }
-  const char *GetTypeKey() const { return ::mlc::base::TypeIndex2TypeInfo(this->type_index)->type_key; }
+  const char *GetTypeKey() const { return Lib::GetTypeKey(this->type_index); }
 
 protected:
   MLC_INLINE void Swap(MLCAny &src) {

include/mlc/base/lib.h

@@ -0,0 +1,87 @@
+#ifndef MLC_BASE_LIB_H_
+#define MLC_BASE_LIB_H_
+
+#include "./utils.h"
+
+namespace mlc {
+
+struct Lib {
+  static int32_t FuncSetGlobal(const char *name, FuncObj *func, bool allow_override = false);
+  static FuncObj *FuncGetGlobal(const char *name, bool allow_missing = false);
+  static ::mlc::Str CxxStr(AnyView obj);
+  static ::mlc::Str Str(AnyView obj);
+  static Any IRPrint(AnyView obj, AnyView printer, AnyView path);
+
+  static FuncObj *_init(int32_t type_index) { return VTableGetFunc(init, type_index, "__init__"); }
+  MLC_INLINE static MLCTypeInfo *GetTypeInfo(int32_t type_index) {
+    MLCTypeInfo *type_info;
+    MLCTypeIndex2Info(_lib, type_index, &type_info);
+    return type_info;
+  }
+  MLC_INLINE static MLCTypeInfo *GetTypeInfo(const char *type_key) {
+    MLCTypeInfo *type_info;
+    MLCTypeKey2Info(_lib, type_key, &type_info);
+    return type_info;
+  }
+  MLC_INLINE static const char *GetTypeKey(int32_t type_index) {
+    if (MLCTypeInfo *type_info = GetTypeInfo(type_index)) {
+      return type_info->type_key;
+    }
+    return "(undefined)";
+  }
+  MLC_INLINE static const char *GetTypeKey(const MLCAny *self) {
+    if (self == nullptr) {
+      return "None";
+    } else if (MLCTypeInfo *type_info = GetTypeInfo(self->type_index)) {
+      return type_info->type_key;
+    }
+    return "(undefined)";
+  }
+  MLC_INLINE static int32_t GetTypeIndex(const char *type_key) {
+    if (MLCTypeInfo *type_info = GetTypeInfo(type_key)) {
+      return type_info->type_index;
+    }
+    MLC_THROW(TypeError) << "Cannot find type with key: " << type_key;
+    MLC_UNREACHABLE();
+  }
+  MLC_INLINE static MLCTypeInfo *TypeRegister(int32_t parent_type_index, int32_t type_index, const char *type_key) {
+    MLCTypeInfo *info = nullptr;
+    MLCTypeRegister(_lib, parent_type_index, type_key, type_index, &info);
+    return info;
+  }
+
+private:
+  static FuncObj *VTableGetFunc(MLCVTableHandle vtable, int32_t type_index, const char *vtable_name) {
+    MLCAny func{};
+    MLCVTableGetFunc(vtable, type_index, true, &func);
+    if (!::mlc::base::IsTypeIndexPOD(func.type_index)) {
+      ::mlc::base::DecRef(func.v.v_obj);
+    }
+    FuncObj *ret = reinterpret_cast<FuncObj *>(func.v.v_obj);
+    if (func.type_index == kMLCNone) {
+      MLC_THROW(TypeError) << "Function `" << vtable_name << "` for type: " << GetTypeKey(type_index)
+                           << " is not defined in the vtable";
+    } else if (func.type_index != kMLCFunc) {
+      MLC_THROW(TypeError) << "Function `" << vtable_name << "` for type: " << GetTypeKey(type_index)
+                           << " is not callable. Its type is " << GetTypeKey(func.type_index);
+    }
+    return ret;
+  }
+  static MLCVTableHandle VTableGetGlobal(const char *name) {
+    MLCVTableHandle ret;
+    MLCVTableGetGlobal(_lib, name, &ret);
+    return ret;
+  }
+  static MLC_SYMBOL_HIDE inline MLCTypeTableHandle _lib = []() {
+    MLCTypeTableHandle ret = nullptr;
+    ::MLCHandleGetGlobal(&ret);
+    return ret;
+  }();
+  static MLC_SYMBOL_HIDE inline MLCVTableHandle cxx_str = VTableGetGlobal("__cxx_str__");
+  static MLC_SYMBOL_HIDE inline MLCVTableHandle str = VTableGetGlobal("__str__");
+  static MLC_SYMBOL_HIDE inline MLCVTableHandle ir_print = VTableGetGlobal("__ir_print__");
+  static MLC_SYMBOL_HIDE inline MLCVTableHandle init = VTableGetGlobal("__init__");
+};
+
+} // namespace mlc
+#endif // MLC_BASE_LIB_H_

include/mlc/base/optional.h

@@ -1,5 +1,6 @@
 #ifndef MLC_BASE_OPTIONAL_H_
 #define MLC_BASE_OPTIONAL_H_
+#include "./lib.h"
 #include "./ref.h"
 #include "./utils.h"
 #include <type_traits>