fix(core): Correct Error Checking (#22)

potatomashed · web-flow · commit 4f414eb64b25 · 2025-02-09T21:19:12.000-08:00
diff --git a/cpp/c_api.cc b/cpp/c_api.cc
@@ -53,8 +53,8 @@ thread_local Any last_error;
 } // namespace
 
 MLC_API MLCAny MLCGetLastError() {
-  MLCAny ret;
-  static_cast<Any &>(ret) = std::move(last_error);
+  MLCAny ret = static_cast<MLCAny &>(last_error);
+  static_cast<MLCAny &>(last_error) = MLCAny();
   return ret;
 }
 
diff --git a/include/mlc/base/lib.h b/include/mlc/base/lib.h
@@ -13,7 +13,7 @@ struct VTable {
     this->Swap(other);
     return *this;
   }
-  ~VTable() { MLC_CHECK_ERR(::MLCVTableDelete(self), nullptr); }
+  ~VTable() { MLC_CHECK_ERR(::MLCVTableDelete(self)); }
 
   template <typename R, typename... Args> R operator()(Args... args) const;
   template <typename Obj> VTable &Set(Func func);
@@ -41,17 +41,17 @@ struct Lib {
   static FuncObj *_init(int32_t type_index) { return VTableGetFunc(init, type_index, "__init__"); }
   static VTable MakeVTable(const char *name) {
     MLCVTableHandle vtable = nullptr;
-    MLC_CHECK_ERR(::MLCVTableCreate(_lib, name, &vtable), nullptr);
+    MLC_CHECK_ERR(::MLCVTableCreate(_lib, name, &vtable));
     return VTable(vtable);
   }
   MLC_INLINE static MLCTypeInfo *GetTypeInfo(int32_t type_index) {
     MLCTypeInfo *type_info = nullptr;
-    MLC_CHECK_ERR(::MLCTypeIndex2Info(_lib, type_index, &type_info), nullptr);
+    MLC_CHECK_ERR(::MLCTypeIndex2Info(_lib, type_index, &type_info));
     return type_info;
   }
   MLC_INLINE static MLCTypeInfo *GetTypeInfo(const char *type_key) {
     MLCTypeInfo *type_info = nullptr;
-    MLC_CHECK_ERR(::MLCTypeKey2Info(_lib, type_key, &type_info), nullptr);
+    MLC_CHECK_ERR(::MLCTypeKey2Info(_lib, type_key, &type_info));
     return type_info;
   }
   MLC_INLINE static const char *GetTypeKey(int32_t type_index) {
@@ -77,14 +77,14 @@ struct Lib {
   }
   MLC_INLINE static MLCTypeInfo *TypeRegister(int32_t parent_type_index, int32_t type_index, const char *type_key) {
     MLCTypeInfo *info = nullptr;
-    MLC_CHECK_ERR(::MLCTypeRegister(_lib, parent_type_index, type_key, type_index, &info), nullptr);
+    MLC_CHECK_ERR(::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{};
-    MLC_CHECK_ERR(::MLCVTableGetFunc(vtable, type_index, true, &func), &func);
+    MLC_CHECK_ERR(::MLCVTableGetFunc(vtable, type_index, true, &func));
     if (!::mlc::base::IsTypeIndexPOD(func.type_index)) {
       ::mlc::base::DecRef(func.v.v_obj);
     }
@@ -100,12 +100,12 @@ struct Lib {
   }
   static MLCVTableHandle VTableGetGlobal(const char *name) {
     MLCVTableHandle ret = nullptr;
-    MLC_CHECK_ERR(::MLCVTableGetGlobal(_lib, name, &ret), nullptr);
+    MLC_CHECK_ERR(::MLCVTableGetGlobal(_lib, name, &ret));
     return ret;
   }
   static MLC_SYMBOL_HIDE inline MLCTypeTableHandle _lib = []() {
     MLCTypeTableHandle ret = nullptr;
-    MLC_CHECK_ERR(::MLCHandleGetGlobal(&ret), nullptr);
+    MLC_CHECK_ERR(::MLCHandleGetGlobal(&ret));
     return ret;
   }();
   static MLC_SYMBOL_HIDE inline MLCVTableHandle cxx_str = VTableGetGlobal("__cxx_str__");
diff --git a/include/mlc/base/utils.h b/include/mlc/base/utils.h
@@ -77,9 +77,9 @@
   }                                                                                                                    \
   MLC_UNREACHABLE()
 
-#define MLC_CHECK_ERR(Call, Ret)                                                                                       \
+#define MLC_CHECK_ERR(Call)                                                                                            \
   if (int32_t err_code = (Call)) {                                                                                     \
-    ::mlc::base::FuncCallCheckError(err_code, (Ret));                                                                  \
+    ::mlc::base::FuncCallCheckError(err_code, nullptr);                                                                \
   }
 
 namespace mlc {
diff --git a/include/mlc/core/all.h b/include/mlc/core/all.h
@@ -147,12 +147,12 @@ inline Any Lib::IRPrint(AnyView obj, AnyView printer, AnyView path) {
   return ret;
 }
 inline int32_t Lib::FuncSetGlobal(const char *name, FuncObj *func, bool allow_override) {
-  MLC_CHECK_ERR(::MLCFuncSetGlobal(_lib, name, Any(func), allow_override), nullptr);
+  MLC_CHECK_ERR(::MLCFuncSetGlobal(_lib, name, Any(func), allow_override));
   return 0;
 }
 inline FuncObj *Lib::FuncGetGlobal(const char *name, bool allow_missing) {
   Any ret;
-  MLC_CHECK_ERR(::MLCFuncGetGlobal(_lib, name, &ret), &ret);
+  MLC_CHECK_ERR(::MLCFuncGetGlobal(_lib, name, &ret));
   if (!ret.defined() && !allow_missing) {
     MLC_THROW(KeyError) << "Missing global function: " << name;
   }
@@ -205,12 +205,12 @@ template <typename R, typename... Args> inline R VTable::operator()(Args... args
   AnyViewArray<N> stack_args;
   Any ret;
   stack_args.Fill(std::forward<Args>(args)...);
-  MLC_CHECK_ERR(::MLCVTableCall(self, N, stack_args.v, &ret), &ret);
+  MLC_CHECK_ERR(::MLCVTableCall(self, N, stack_args.v, &ret));
+  return ret;
 }
 template <typename Obj> inline VTable &VTable::Set(Func func) {
   constexpr bool override_mode = false;
-  int32_t type_index = Obj::_type_index;
-  MLC_CHECK_ERR(::MLCVTableSetFunc(this->self, type_index, func.get(), override_mode), nullptr);
+  MLC_CHECK_ERR(::MLCVTableSetFunc(this->self, Obj::_type_index, func.get(), override_mode));
   return *this;
 }
 
diff --git a/include/mlc/core/func.h b/include/mlc/core/func.h
@@ -104,8 +104,8 @@ inline void FuncCall(const void *self, int32_t num_args, const MLCAny *args, MLC
   const MLCFunc *func = static_cast<const MLCFunc *>(self);
   if (func->call && reinterpret_cast<void *>(func->safe_call) == reinterpret_cast<void *>(FuncObj::SafeCallImpl)) {
     func->call(func, num_args, args, ret);
-  } else {
-    MLC_CHECK_ERR(func->safe_call(func, num_args, args, ret), ret);
+  } else if (int32_t err_code = func->safe_call(func, num_args, args, ret)) {
+    FuncCallCheckError(err_code, ret);
   }
 }
 template <int32_t num_args> inline auto GetGlobalFuncCall(const char *name) {
diff --git a/include/mlc/core/func_details.h b/include/mlc/core/func_details.h
@@ -190,12 +190,16 @@ template <typename FuncType, typename> MLC_INLINE FuncObj *FuncObj::Allocator::N
 inline Ref<FuncObj> FuncObj::FromForeign(void *self, MLCDeleterType deleter, MLCFuncSafeCallType safe_call) {
   if (deleter == nullptr) {
     return Ref<FuncObj>::New([self, safe_call](int32_t num_args, const MLCAny *args, MLCAny *ret) {
-      MLC_CHECK_ERR(safe_call(self, num_args, args, ret), ret);
+      if (int32_t err_code = safe_call(self, num_args, args, ret)) {
+        ::mlc::base::FuncCallCheckError(err_code, ret);
+      }
     });
   } else {
     return Ref<FuncObj>::New(
         [self = std::shared_ptr<void>(self, deleter), safe_call](int32_t num_args, const MLCAny *args, MLCAny *ret) {
-          MLC_CHECK_ERR(safe_call(self.get(), num_args, args, ret), ret);
+          if (int32_t err_code = safe_call(self.get(), num_args, args, ret)) {
+            ::mlc::base::FuncCallCheckError(err_code, ret);
+          }
         });
   }
 }
diff --git a/include/mlc/core/reflection.h b/include/mlc/core/reflection.h
@@ -100,14 +100,12 @@ struct _Reflect {
                                                  reinterpret_cast<MLCFunc *>(func_any_to_ref.v.v_obj), //
                                                  kStaticFn});
       }
-      MLC_CHECK_ERR(::MLCTypeRegisterFields(nullptr, this->type_index, this->fields.size(), this->fields.data()),
-                    nullptr);
+      MLC_CHECK_ERR(::MLCTypeRegisterFields(nullptr, this->type_index, this->fields.size(), this->fields.data()));
       MLC_CHECK_ERR(::MLCTypeRegisterStructure(nullptr, this->type_index, static_cast<int32_t>(this->structure_kind),
                                                this->sub_structure_indices.size(), this->sub_structure_indices.data(),
-                                               this->sub_structure_kinds.data()),
-                    nullptr);
+                                               this->sub_structure_kinds.data()));
       for (const MLCTypeMethod &method : this->methods) {
-        MLC_CHECK_ERR(::MLCTypeAddMethod(nullptr, this->type_index, method), nullptr);
+        MLC_CHECK_ERR(::MLCTypeAddMethod(nullptr, this->type_index, method));
       }
     }
     return 0;

Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,8 @@ thread_local Any last_error;`
`53`	`53`	`} // namespace`
`54`	`54`
`55`	`55`	`MLC_API MLCAny MLCGetLastError() {`
`56`		`- MLCAny ret;`
`57`		`- static_cast<Any &>(ret) = std::move(last_error);`
	`56`	`+ MLCAny ret = static_cast<MLCAny &>(last_error);`
	`57`	`+ static_cast<MLCAny &>(last_error) = MLCAny();`
`58`	`58`	`return ret;`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -147,12 +147,12 @@ inline Any Lib::IRPrint(AnyView obj, AnyView printer, AnyView path) {`
`147`	`147`	`return ret;`
`148`	`148`	`}`
`149`	`149`	`inline int32_t Lib::FuncSetGlobal(const char name, FuncObj func, bool allow_override) {`
`150`		`- MLC_CHECK_ERR(::MLCFuncSetGlobal(_lib, name, Any(func), allow_override), nullptr);`
	`150`	`+ MLC_CHECK_ERR(::MLCFuncSetGlobal(_lib, name, Any(func), allow_override));`
`151`	`151`	`return 0;`
`152`	`152`	`}`
`153`	`153`	`inline FuncObj Lib::FuncGetGlobal(const char name, bool allow_missing) {`
`154`	`154`	`Any ret;`
`155`		`- MLC_CHECK_ERR(::MLCFuncGetGlobal(_lib, name, &ret), &ret);`
	`155`	`+ MLC_CHECK_ERR(::MLCFuncGetGlobal(_lib, name, &ret));`
`156`	`156`	`if (!ret.defined() && !allow_missing) {`
`157`	`157`	`MLC_THROW(KeyError) << "Missing global function: " << name;`
`158`	`158`	`}`
`@@ -205,12 +205,12 @@ template <typename R, typename... Args> inline R VTable::operator()(Args... args`
`205`	`205`	`AnyViewArray<N> stack_args;`
`206`	`206`	`Any ret;`
`207`	`207`	`stack_args.Fill(std::forward<Args>(args)...);`
`208`		`- MLC_CHECK_ERR(::MLCVTableCall(self, N, stack_args.v, &ret), &ret);`
	`208`	`+ MLC_CHECK_ERR(::MLCVTableCall(self, N, stack_args.v, &ret));`
	`209`	`+ return ret;`
`209`	`210`	`}`
`210`	`211`	`template <typename Obj> inline VTable &VTable::Set(Func func) {`
`211`	`212`	`constexpr bool override_mode = false;`
`212`		`- int32_t type_index = Obj::_type_index;`
`213`		`- MLC_CHECK_ERR(::MLCVTableSetFunc(this->self, type_index, func.get(), override_mode), nullptr);`
	`213`	`+ MLC_CHECK_ERR(::MLCVTableSetFunc(this->self, Obj::_type_index, func.get(), override_mode));`
`214`	`214`	`return *this;`
`215`	`215`	`}`
`216`	`216`
Original file line number	Diff line number	Diff line change
`@@ -104,8 +104,8 @@ inline void FuncCall(const void self, int32_t num_args, const MLCAny args, MLC`
`104`	`104`	`const MLCFunc func = static_cast<const MLCFunc >(self);`
`105`	`105`	`if (func->call && reinterpret_cast<void >(func->safe_call) == reinterpret_cast<void >(FuncObj::SafeCallImpl)) {`
`106`	`106`	`func->call(func, num_args, args, ret);`
`107`		`- } else {`
`108`		`- MLC_CHECK_ERR(func->safe_call(func, num_args, args, ret), ret);`
	`107`	`+ } else if (int32_t err_code = func->safe_call(func, num_args, args, ret)) {`
	`108`	`+ FuncCallCheckError(err_code, ret);`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`template <int32_t num_args> inline auto GetGlobalFuncCall(const char *name) {`
Original file line number	Diff line number	Diff line change
`@@ -100,14 +100,12 @@ struct _Reflect {`
`100`	`100`	`reinterpret_cast<MLCFunc *>(func_any_to_ref.v.v_obj), //`
`101`	`101`	`kStaticFn});`
`102`	`102`	`}`
`103`		`- MLC_CHECK_ERR(::MLCTypeRegisterFields(nullptr, this->type_index, this->fields.size(), this->fields.data()),`
`104`		`- nullptr);`
	`103`	`+ MLC_CHECK_ERR(::MLCTypeRegisterFields(nullptr, this->type_index, this->fields.size(), this->fields.data()));`
`105`	`104`	`MLC_CHECK_ERR(::MLCTypeRegisterStructure(nullptr, this->type_index, static_cast<int32_t>(this->structure_kind),`
`106`	`105`	`this->sub_structure_indices.size(), this->sub_structure_indices.data(),`
`107`		`- this->sub_structure_kinds.data()),`
`108`		`- nullptr);`
	`106`	`+ this->sub_structure_kinds.data()));`
`109`	`107`	`for (const MLCTypeMethod &method : this->methods) {`
`110`		`- MLC_CHECK_ERR(::MLCTypeAddMethod(nullptr, this->type_index, method), nullptr);`
	`108`	`+ MLC_CHECK_ERR(::MLCTypeAddMethod(nullptr, this->type_index, method));`
`111`	`109`	`}`
`112`	`110`	`}`
`113`	`111`	`return 0;`