Vipul-Cariappa · Oct 13, 2026 · Oct 13, 2026 · Oct 14, 2026 · Oct 7, 2026 · Oct 9, 2026
@@ -257,7 +257,17 @@ def merge_values(mergeable_out, mergeable_in):
     Generally the arguments are `RMergeableValue` instances that can be directly
     passed to the C++ function responsible for merging them.
     """
-    ROOT.Detail.RDF.MergeValues(mergeable_out, mergeable_in)
+    # The mergeables are usually held by std::unique_ptrs: pass the objects
+    # themselves, as passing the smart pointers would select the MergeValues
+    # overload that takes (and thus moves) them by value.
+    ROOT.Detail.RDF.MergeValues(_pointee(mergeable_out), _pointee(mergeable_in))
+
+
+def _pointee(obj):
+    """Return the object a smart pointer proxy points to, or the object itself."""
+    smartptr = getattr(obj, "__smartptr__", None)
+    smartptr = smartptr() if smartptr is not None else None
+    return smartptr.get() if smartptr else obj
 
 
 @merge_values.register(AsNumpyResult)

@@ -10,6 +10,8 @@ include(GNUInstallDirs)
 # This option won't make a lot of sense since we only ship the shared library in site-packages
 # Perhaps this should permanently be OFF and users can build their own CppInterOp if they want to run the tests?
 option(CPPJIT_ENABLE_CPPINTEROP_TESTS "enable CppInterOp tests" OFF)
+# Temporary pin to the overload-resolution development branch so CI builds
+# and tests it. Returns to a pinned commit once that branch lands.
 set(CPPINTEROP_GIT_REPOSITORY "https://github.com/compiler-research/CppInterOp.git" CACHE STRING "")
 set(CPPINTEROP_GIT_TAG "c8126249dd18363000b89333b34313ca2a83fb82" CACHE STRING "")
 set(CPPINTEROP_SOURCE_DIR "" CACHE PATH

@@ -25,6 +25,8 @@
     "_end_capture_stderr",
     "_lock_interpreter",
     "_unlock_interpreter",
+    "OverloadResolutionException",
+    "OverloadAmbiguityException",
 ]
 
 
@@ -207,6 +209,8 @@ def _add_default_paths():
 bind_object = _backend.bind_object
 nullptr = _backend.nullptr
 default = _backend.default
+OverloadResolutionException = _backend.OverloadResolutionException
+OverloadAmbiguityException = _backend.OverloadAmbiguityException
 
 
 def load_reflection_info(name):

@@ -145,10 +145,6 @@ typedef Converter* (*ConverterFactory_t)(cdims_t);
 CPYRT_EXTERN bool RegisterConverter(const std::string& name,
                                     ConverterFactory_t);
 
-// register a custom converter that is a reference to an existing converter
-CPYRT_EXTERN bool RegisterConverterAlias(const std::string& name,
-                                         const std::string& target);
-
 // remove a custom converter
 CPYRT_EXTERN bool UnregisterConverter(const std::string& name);
 
@@ -176,10 +172,6 @@ CPYRT_EXTERN void DestroyConverter(Converter* p);
 typedef Executor* (*ExecutorFactory_t)(cdims_t);
 CPYRT_EXTERN bool RegisterExecutor(const std::string& name, ExecutorFactory_t);
 
-// register a custom executor that is a reference to an existing converter
-CPYRT_EXTERN bool RegisterExecutorAlias(const std::string& name,
-                                        const std::string& target);
-
 // remove a custom executor
 CPYRT_EXTERN bool UnregisterExecutor(const std::string& name);
 

@@ -359,8 +359,7 @@ void cpyrt::CPPDataMember::Set(interop::TCppScope_t scope,
     type = interop::GetDatamemberType(fScope);
     fFullType = interop::GetTypeAsString(type);
 
-    // Get the integer type if it's an enum
-    if (interop::IsEnumType(type))
+    if (interop::IsEnumType(type) && fFullType == "std::byte")
       type = interop::ResolveType(type);
 
     if (interop::IsConstVar(fScope))
@@ -382,17 +381,6 @@ void cpyrt::CPPDataMember::Set(interop::TCppScope_t scope,
     fDescription = PyUnicode_FromString(name.c_str());
 }
 
-//-----------------------------------------------------------------------------
-void cpyrt::CPPDataMember::Set(interop::TCppScope_t scope,
-                               const std::string& name, void* address) {
-  fEnclosingScope = scope;
-  fDescription = PyUnicode_FromString(name.c_str());
-  fOffset = (intptr_t)address;
-  fFlags = kIsStaticData | kIsConstData;
-  fConverter = CreateConverter("internal_enum_type_t");
-  fFullType = "unsigned int";
-}
-
 //-----------------------------------------------------------------------------
 void* cpyrt::CPPDataMember::GetAddress(CPPInstance* pyobj) {
   // class attributes, global properties

@@ -14,7 +14,6 @@ class CPPInstance;
 class CPPDataMember {
 public:
   void Set(interop::TCppScope_t scope, interop::TCppScope_t var);
-  void Set(interop::TCppScope_t scope, const std::string& name, void* address);
 
   std::string GetName();
   void* GetAddress(CPPInstance* pyobj /* owner */);
@@ -57,16 +56,6 @@ inline CPPDataMember* CPPDataMember_New(interop::TCppScope_t scope,
   return pyprop;
 }
 
-inline CPPDataMember* CPPDataMember_NewConstant(interop::TCppScope_t scope,
-                                                const std::string& name,
-                                                void* address) {
-  // Create an initialize a new property descriptor, given the C++ datum.
-  CPPDataMember* pyprop = (CPPDataMember*)CPPDataMember_Type.tp_new(
-      &CPPDataMember_Type, nullptr, nullptr);
-  pyprop->Set(scope, name, address);
-  return pyprop;
-}
-
 } // namespace cppjit::cpyrt
 
 #endif // !CPYRT_CPPDATAMEMBER_H
@@ -1,6 +1,9 @@
 #ifndef CPYRT_CPPEXCINSTANCE_H
 #define CPYRT_CPPEXCINSTANCE_H
 
+#include "Python.h"
+#include "cpyrt/CommonDefs.h"
+
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
 // cppjit::cpyrt::CPPExceptionInstance                                      //

@@ -42,51 +42,6 @@ extern PyObject* gNullPtrObject;
 // pointer to the smart pointer. They carry a pointer to the Python-sode smart
 // class for dereferencing to get to the actual instance pointer.
 
-//- private helpers ----------------------------------------------------------
-namespace {
-
-// Several specific use cases require extra data in a CPPInstance, but can not
-// be a new type. E.g. cross-inheritance derived types are by definition added
-// a posterio, and caching of datamembers is up to the datamember, not the
-// instance type. To not have normal use of CPPInstance take extra memory, this
-// extended data can slot in place of fObject for those use cases.
-
-struct ExtendedData {
-  ExtendedData()
-      : fObject(nullptr), fSmartClass(nullptr), fDispatchPtr(nullptr),
-        fArraySize(0) {}
-  ~ExtendedData() {
-    for (auto& pc : fDatamemberCache)
-      Py_XDECREF(pc.second);
-    fDatamemberCache.clear();
-  }
-
-  // the original object reference it replaces (Note: has to be first data
-  // member, see usage in GetObjectRaw(), e.g. for ptr-ptr passing)
-  void* fObject;
-
-  // for caching expensive-to-create data member representations
-  cpyrt::CI_DatamemberCache_t fDatamemberCache;
-
-  // for smart pointer types
-  cpyrt::CPPSmartClass* fSmartClass;
-
-  // for back-referencing from Python-derived instances
-  cpyrt::DispatchPtr* fDispatchPtr;
-
-  // for representing T* as a low-level array
-  Py_ssize_t fArraySize;
-};
-
-} // unnamed namespace
-
-#define EXT_OBJECT(pyobj) ((ExtendedData*)((pyobj)->fObject))->fObject
-#define DATA_CACHE(pyobj) ((ExtendedData*)((pyobj)->fObject))->fDatamemberCache
-#define SMART_CLS(pyobj) ((ExtendedData*)((pyobj)->fObject))->fSmartClass
-#define SMART_TYPE(pyobj) SMART_CLS(pyobj)->fCppType
-#define DISPATCHPTR(pyobj) ((ExtendedData*)((pyobj)->fObject))->fDispatchPtr
-#define ARRAY_SIZE(pyobj) ((ExtendedData*)((pyobj)->fObject))->fArraySize
-
 inline void cpyrt::CPPInstance::CreateExtension() {
   if (fFlags & kIsExtended)
     return;
@@ -549,7 +504,8 @@ static inline PyObject* eqneq_binop(CPPClass* klass, PyObject* self,
     const char* cppop = op == Py_EQ ? "==" : "!=";
     PyCallable* pyfunc = FindBinaryOperator(self, obj, cppop);
     if (pyfunc)
-      binop = (PyObject*)CPPOverload_New(cppop, pyfunc);
+      binop = (PyObject*)CPPOverload_New(
+          cppop, interop::GetParentScope(pyfunc->GetMethod().data), pyfunc);
     else {
       Py_INCREF(Py_None);
       binop = Py_None;
@@ -613,7 +569,8 @@ static inline void* cast_actual(void* obj) {
     PyCallable* pyfunc =                                                       \
         Utility::FindBinaryOperator((PyObject*)self, other, #op);              \
     if (pyfunc)                                                                \
-      ometh = (PyObject*)CPPOverload_New(#label, pyfunc);                      \
+      ometh = (PyObject*)CPPOverload_New(                                      \
+          #label, interop::GetParentScope(pyfunc->GetMethod().data), pyfunc);  \
   }                                                                            \
   meth = ometh;
 
@@ -1005,7 +962,8 @@ static PyGetSetDef op_getset[] = {
     PyErr_Clear();                                                             \
     PyCallable* pyfunc = Utility::FindBinaryOperator(left, right, #op);        \
     if (pyfunc)                                                                \
-      meth = (PyObject*)CPPOverload_New(#name, pyfunc);                        \
+      meth = (PyObject*)CPPOverload_New(                                       \
+          #name, interop::GetParentScope(pyfunc->GetMethod().data), pyfunc);   \
     else {                                                                     \
       PyErr_SetString(PyExc_NotImplementedError, "");                          \
       return nullptr;                                                          \

@@ -17,6 +17,8 @@
 #include "CommonDefs.h"
 #include "cppjit_interop.h"
 
+#include "cpyrt/DispatchPtr.h"
+
 // Standard
 #include <utility>
 #include <vector>
@@ -146,4 +148,49 @@ void op_dealloc_nofree(CPPInstance*);
 
 } // namespace cppjit::cpyrt
 
+//- private helpers ----------------------------------------------------------
+namespace {
+
+// Several specific use cases require extra data in a CPPInstance, but can not
+// be a new type. E.g. cross-inheritance derived types are by definition added
+// a posterio, and caching of datamembers is up to the datamember, not the
+// instance type. To not have normal use of CPPInstance take extra memory, this
+// extended data can slot in place of fObject for those use cases.
+
+struct ExtendedData {
+  ExtendedData()
+      : fObject(nullptr), fSmartClass(nullptr), fDispatchPtr(nullptr),
+        fArraySize(0) {}
+  ~ExtendedData() {
+    for (auto& pc : fDatamemberCache)
+      Py_XDECREF(pc.second);
+    fDatamemberCache.clear();
+  }
+
+  // the original object reference it replaces (Note: has to be first data
+  // member, see usage in GetObjectRaw(), e.g. for ptr-ptr passing)
+  void* fObject;
+
+  // for caching expensive-to-create data member representations
+  cppjit::cpyrt::CI_DatamemberCache_t fDatamemberCache;
+
+  // for smart pointer types
+  cppjit::cpyrt::CPPSmartClass* fSmartClass;
+
+  // for back-referencing from Python-derived instances
+  cppjit::cpyrt::DispatchPtr* fDispatchPtr;
+
+  // for representing T* as a low-level array
+  Py_ssize_t fArraySize;
+};
+
+} // unnamed namespace
+
+#define EXT_OBJECT(pyobj) ((ExtendedData*)((pyobj)->fObject))->fObject
+#define DATA_CACHE(pyobj) ((ExtendedData*)((pyobj)->fObject))->fDatamemberCache
+#define SMART_CLS(pyobj) ((ExtendedData*)((pyobj)->fObject))->fSmartClass
+#define SMART_TYPE(pyobj) SMART_CLS(pyobj)->fCppType
+#define DISPATCHPTR(pyobj) ((ExtendedData*)((pyobj)->fObject))->fDispatchPtr
+#define ARRAY_SIZE(pyobj) ((ExtendedData*)((pyobj)->fObject))->fArraySize
+
 #endif // !CPYRT_CPPINSTANCE_H