From ca82231c579f1cf8d799a5de4d5324ea5d8472c8 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Tue, 25 Aug 2026 15:17:59 +0200 Subject: [PATCH 01/17] Improve error reporting for method calls without a C++ object (#41) * [cpyrt] Improve error reporting for method calls without C++ object Co-Authored-By: Claude Fable 5 * [test] Add test for method calls on an instance without a C++ object Co-Authored-By: Claude Fable 5 --------- Co-authored-by: Grigori Rybkine Co-authored-by: Claude Fable 5 --- src/cpyrt/CPPMethod.cxx | 3 ++- src/cpyrt/CPPOverload.cxx | 3 ++- test/test_fragile.py | 18 ++++++++++++++++++ 3 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/cpyrt/CPPMethod.cxx b/src/cpyrt/CPPMethod.cxx index 761d0ed..3f0d0e5 100644 --- a/src/cpyrt/CPPMethod.cxx +++ b/src/cpyrt/CPPMethod.cxx @@ -1058,7 +1058,8 @@ PyObject* cpyrt::CPPMethod::Call(CPPInstance*& self, cpyrt_PyArgs_t args, // validity check that should not fail if (!object) { - PyErr_SetString(PyExc_ReferenceError, "attempt to access a null-pointer"); + PyErr_SetString(PyExc_ReferenceError, "no C++ object available"); + ctxt->fFlags |= CallContext::kCppException; return nullptr; } diff --git a/src/cpyrt/CPPOverload.cxx b/src/cpyrt/CPPOverload.cxx index 8bda467..49778df 100644 --- a/src/cpyrt/CPPOverload.cxx +++ b/src/cpyrt/CPPOverload.cxx @@ -624,7 +624,8 @@ static PyObject* mp_vectorcall(CPPOverload* pymeth, PyObject* const* args, return HandleReturn(pymeth, im_self, result); // fall through: python is dynamic, and so, the hashing isn't infallible - ctxt.fFlags &= ~CallContext::kAllowImplicit; + ctxt.fFlags &= ~(CallContext::kAllowImplicit | CallContext::kPyException | + CallContext::kCppException); PyErr_Clear(); ResetCallState(pymeth->fSelf, im_self); } diff --git a/test/test_fragile.py b/test/test_fragile.py index 181a38b..e4cf3bc 100644 --- a/test/test_fragile.py +++ b/test/test_fragile.py @@ -761,6 +761,24 @@ def test31_template_with_class_enum(self): for ns, val in [(cppjit.gbl, 42), (cppjit.gbl.ClassEnumNS, 37)]: assert ns.EnumTemplate[ns.ClassEnumA.A]().foo() == val + def test32_overloaded_method_error_with_null_object(self): + """Check exception type and message when method invoked on instance without C++ object""" + + import cppjit + from cppjit import gbl + + cppjit.cppdef(r"""\ + using fragile::D; + D *something = new D; + D *nothing = nullptr; + """) + + assert gbl.something.check() == gbl.something.check(0, 1) + with raises(ReferenceError, match=r"^no C\+\+ object available$"): + gbl.nothing.check() # raises error + with raises(ReferenceError, match=r"^no C\+\+ object available$"): + gbl.nothing.check(0, 1) # raises error + class TestSIGNALS: def setup_class(cls): From 323503946e59904de07f4c4ede355a9bc514a8d2 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Tue, 25 Aug 2026 15:18:35 +0200 Subject: [PATCH 02/17] Penalize void* arguments in overload priority as intended (#40) * [cpyrt] Penalize void* arguments in overload priority as intended * [test] Add regression test for void* overload priority --------- Co-authored-by: Emery Conrad Co-authored-by: Claude Fable 5 --- src/cpyrt/CPPMethod.cxx | 13 ++++++++----- test/test_overloads.py | 29 +++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 5 deletions(-) diff --git a/src/cpyrt/CPPMethod.cxx b/src/cpyrt/CPPMethod.cxx index 3f0d0e5..3fe3e37 100644 --- a/src/cpyrt/CPPMethod.cxx +++ b/src/cpyrt/CPPMethod.cxx @@ -529,7 +529,14 @@ int cpyrt::CPPMethod::GetPriority() { // type: // interop::TCppType_t type = interop::GetMethodArgType(fMethod, iarg); - if (interop::IsBuiltin(aname)) { + // Not builtin and spelled "const void *", so match the compacted name. + std::string compact = aname; + compact.erase(std::remove(compact.begin(), compact.end(), ' '), + compact.end()); + + if (compact.find("void*") != std::string::npos) { + priority -= 1000; // void*/void** shouldn't be too greedy + } else if (interop::IsBuiltin(aname)) { // complex type (note: double penalty: for complex and the template type) if (strstr(aname.c_str(), "std::complex")) priority -= 10; // prefer double, float, etc. over conversion @@ -557,10 +564,6 @@ int cpyrt::CPPMethod::GetPriority() { else if (strstr(aname.c_str(), "char") && aname[aname.size() - 1] != '*') priority += -60; // prefer (const) char* over char - // oddball - else if (strstr(aname.c_str(), "void*")) - priority -= 1000; // void*/void** shouldn't be too greedy - } else { // This is a user-defined type (class, struct, enum, etc.). diff --git a/test/test_overloads.py b/test/test_overloads.py index 24b8d0a..f736c8a 100644 --- a/test/test_overloads.py +++ b/test/test_overloads.py @@ -411,3 +411,32 @@ def test15_disallow_mutable_pointer_references(self): ptr = cppjit.gbl.MyClass() raises(TypeError, cppjit.gbl.changePtr, ptr) + + def test16_voidp_does_not_outrank_conversion(self): + """Verify that a const void* overload does not shadow a converting one.""" + + import cppjit + + cppjit.cppdef(""" + namespace VoidPPriority { + struct Handle { + void* data; + Handle() : data(nullptr) {} + Handle(void* p) : data(p) {} + }; + struct ConstHandle { + const void* data; + ConstHandle() : data(nullptr) {} + ConstHandle(const void* p) : data(p) {} // declared first on purpose + ConstHandle(Handle h) : data(h.data) {} + }; + Handle make_handle() { return Handle((void*)0xABCD1234); } + bool kept_value(ConstHandle c) { return c.data == (const void*)0xABCD1234; } + }""") + + ns = cppjit.gbl.VoidPPriority + + # taking ConstHandle(const void*) would pass the proxy's address instead + h = ns.make_handle() + assert ns.kept_value(h) + assert ns.kept_value(ns.make_handle()) From 46cde5532b02c824b02b1d624504f6b009573dfa Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Wed, 26 Aug 2026 16:18:07 +0200 Subject: [PATCH 03/17] Unify installed layout under cppjit, drop backend (#43) --- CMakeLists.txt | 22 +++++++++++----------- pyproject.toml | 2 +- python/cppjit/__init__.py | 4 ++-- python/cppjit/_cpython_cppjit.py | 6 +++--- python/cppjit_backend/__init__.py | 1 - python/cppjit_backend/_version.py | 1 - 6 files changed, 17 insertions(+), 19 deletions(-) delete mode 100644 python/cppjit_backend/__init__.py delete mode 100644 python/cppjit_backend/_version.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 7158a15..50403dc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -101,7 +101,7 @@ if(_python_platlib) else() set(CPPINTEROP_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") endif() -set(CPPINTEROP_INSTALL_DIR "${CPPINTEROP_INSTALL_PREFIX}/cppjit_backend") +set(CPPINTEROP_INSTALL_DIR "${CPPINTEROP_INSTALL_PREFIX}/cppjit/interop") # Include cmake for CppInterOp config and build using ExternalProject. include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/AddCppInterOp.cmake) @@ -121,11 +121,11 @@ add_dependencies(cppjit CppInterOp) # falling back to the install prefix (see cppinterop_paths()); the clang # major names the versioned compiler probed for the runtime resource dir. target_compile_definitions(cppjit PRIVATE - CPPINTEROP_INSTALL_PREFIX="${CPPINTEROP_INSTALL_PREFIX}" - CPPINTEROP_LIBRARY="cppjit_backend/lib/libclangCppInterOp${CMAKE_SHARED_LIBRARY_SUFFIX}" - CPPINTEROP_INCLUDE_DIR="cppjit_backend/include" + CPPINTEROP_INSTALL_PREFIX="${CPPINTEROP_INSTALL_PREFIX}/cppjit" + CPPINTEROP_LIBRARY="interop/lib/libclangCppInterOp${CMAKE_SHARED_LIBRARY_SUFFIX}" + CPPINTEROP_INCLUDE_DIR="interop/include" CPPJIT_CLANG_MAJOR="${LLVM_VERSION_MAJOR}" - CPPJIT_CLANG_INCLUDE_DIR="cppjit_backend/lib/clang/${LLVM_VERSION_MAJOR}" + CPPJIT_CLANG_INCLUDE_DIR="interop/lib/clang/${LLVM_VERSION_MAJOR}" ) target_include_directories(cppjit PRIVATE @@ -159,21 +159,21 @@ set_target_properties(cppjit PROPERTIES PREFIX "lib" ) -# libcppjit.so is installed at the site-packages root (import libcppjit) +# the extension lives inside the package (import cppjit.libcppjit) install(TARGETS cppjit - LIBRARY DESTINATION . + LIBRARY DESTINATION cppjit ) # install CppInterOp libraries and headers install(CODE " file(GLOB _interop_libs \"${CPPINTEROP_INSTALL_DIR}/lib/libclangCppInterOp*\") foreach(_lib \${_interop_libs}) - file(INSTALL \${_lib} DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit_backend/lib) + file(INSTALL \${_lib} DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/interop/lib) endforeach() ") install(CODE " - file(INSTALL \"${CPPINTEROP_INSTALL_DIR}/include/\" DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit_backend/include) + file(INSTALL \"${CPPINTEROP_INSTALL_DIR}/include/\" DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/interop/include) ") # ship the builtin headers of the build clang, laid out as a headers-only @@ -185,7 +185,7 @@ if(NOT EXISTS "${_clang_resource_dir}/include") "${LLVM_DIR} carries no clang resource directory") endif() install(DIRECTORY "${_clang_resource_dir}/include/" - DESTINATION "cppjit_backend/lib/clang/${LLVM_VERSION_MAJOR}/include" + DESTINATION "cppjit/interop/lib/clang/${LLVM_VERSION_MAJOR}/include" ) # the public cpyrt API headers keep their installed cpyrt/ prefix @@ -195,5 +195,5 @@ install(FILES src/cpyrt/DispatchPtr.h src/cpyrt/PyException.h src/cpyrt/Reflex.h - DESTINATION cppjit_backend/include/cpyrt + DESTINATION cppjit/interop/include/cpyrt ) diff --git a/pyproject.toml b/pyproject.toml index 9878475..5308b63 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,7 +22,7 @@ maintainers = [ [tool.scikit-build] wheel.install-dir = "." -wheel.packages = ["python/cppjit", "python/cppjit_backend"] +wheel.packages = ["python/cppjit"] cmake.build-type = "Release" [[tool.dynamic-metadata]] diff --git a/python/cppjit/__init__.py b/python/cppjit/__init__.py index ae87217..6280d6e 100644 --- a/python/cppjit/__init__.py +++ b/python/cppjit/__init__.py @@ -348,10 +348,10 @@ def _setup_include_paths(): if os.path.basename(apipath_extra) == "cpyrt": apipath_extra = os.path.dirname(apipath_extra) else: - spec = importlib.util.find_spec("libcppjit") + spec = importlib.util.find_spec("cppjit.libcppjit") if spec is not None and spec.origin: apipath_extra = os.path.join( - os.path.dirname(spec.origin), "cppjit_backend", "include" + os.path.dirname(spec.origin), "interop", "include" ) if apipath_extra and apipath_extra.lower() != "none": diff --git a/python/cppjit/_cpython_cppjit.py b/python/cppjit/_cpython_cppjit.py index 0b11ec3..50a32f3 100644 --- a/python/cppjit/_cpython_cppjit.py +++ b/python/cppjit/_cpython_cppjit.py @@ -21,9 +21,9 @@ def _preload_backend_library(): # preload the merged extension with ctypes and run LoadCppInterOp() first, # so the interpreter is ready before the extension module initializes - spec = importlib.util.find_spec("libcppjit") + spec = importlib.util.find_spec("cppjit.libcppjit") if spec is None or not spec.origin: - raise ImportError("cannot locate the libcppjit extension module") + raise ImportError("cannot locate the cppjit.libcppjit extension module") lib = ctypes.CDLL(spec.origin, ctypes.RTLD_GLOBAL) if not lib.LoadCppInterOp(): raise RuntimeError("failed to load CppInterOp (LoadCppInterOp returned 0)") @@ -32,7 +32,7 @@ def _preload_backend_library(): _w = _preload_backend_library() -import libcppjit as _backend # noqa: E402 +from . import libcppjit as _backend # noqa: E402 ### template support --------------------------------------------------------- diff --git a/python/cppjit_backend/__init__.py b/python/cppjit_backend/__init__.py deleted file mode 100644 index aab79a8..0000000 --- a/python/cppjit_backend/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from ._version import __version__ as __version__ diff --git a/python/cppjit_backend/_version.py b/python/cppjit_backend/_version.py deleted file mode 100644 index 3dc1f76..0000000 --- a/python/cppjit_backend/_version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "0.1.0" From 821257bd68848e39ae44d7659bddbd710344bd83 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Wed, 26 Aug 2026 17:24:55 +0200 Subject: [PATCH 04/17] Add single header for interop API/types used by cpyrt (#42) Fixes the long-standing header duplication (previously `Cppyy.h` and `cpp_cppyy.h`) between cpyrt and interop, so that there is only a single source of definitions for the `cppjit::interop` API and types. --- src/cpyrt/CallContext.h | 36 +- src/cpyrt/cppjit_interop.h | 467 ------------------ src/interop/callcontext.h | 21 +- .../{cpp_cppjit.h => cppjit_interop.h} | 15 +- src/interop/interop_wrapper.cxx | 12 +- 5 files changed, 30 insertions(+), 521 deletions(-) delete mode 100644 src/cpyrt/cppjit_interop.h rename src/interop/{cpp_cppjit.h => cppjit_interop.h} (96%) diff --git a/src/cpyrt/CallContext.h b/src/cpyrt/CallContext.h index cf614f1..b52915b 100644 --- a/src/cpyrt/CallContext.h +++ b/src/cpyrt/CallContext.h @@ -12,40 +12,8 @@ namespace cppjit::cpyrt { -// small number that allows use of stack for argument passing -const int SMALL_ARGS_N = 8; - -// convention to pass flag for direct calls (similar to Python's vector calls) -#define DIRECT_CALL ((size_t)1 << (8 * sizeof(size_t) - 1)) - -#ifndef CPYRT_PARAMETER -#define CPYRT_PARAMETER -// general place holder for function parameters -struct Parameter { - union Value { - bool fBool; - int8_t fInt8; - uint8_t fUInt8; - short fShort; - unsigned short fUShort; - int fInt; - unsigned int fUInt; - long fLong; - intptr_t fIntPtr; - unsigned long fULong; - long long fLLong; - unsigned long long fULLong; - int64_t fInt64; - uint64_t fUInt64; - float fFloat; - double fDouble; - long double fLDouble; - void* fVoidp; - } fValue; - void* fRef; - char fTypeCode; -}; -#endif // CPYRT_PARAMETER +// Parameter and the call-ABI constants (SMALL_ARGS_N, DIRECT_CALL) come +// from the interop callcontext.h via cppjit_interop.h // extra call information struct CallContext { diff --git a/src/cpyrt/cppjit_interop.h b/src/cpyrt/cppjit_interop.h deleted file mode 100644 index f2cdb69..0000000 --- a/src/cpyrt/cppjit_interop.h +++ /dev/null @@ -1,467 +0,0 @@ -#ifndef CPYRT_CPPJIT_H -#define CPYRT_CPPJIT_H - -// Standard -#include -#include -#include -#include -#include - -// import/export (after precommondefs.h from PyPy) -#ifdef _MSC_VER -#define CPPJIT_IMPORT extern __declspec(dllimport) -#else -#define CPPJIT_IMPORT extern -#endif - -// some more types; assumes cppjit_interop.h follows Python.h -#ifndef PY_LONG_LONG -#ifdef _WIN32 -typedef __int64 PY_LONG_LONG; -#else -typedef long long PY_LONG_LONG; -#endif -#endif - -#ifndef PY_ULONG_LONG -#ifdef _WIN32 -typedef unsigned __int64 PY_ULONG_LONG; -#else -typedef unsigned long long PY_ULONG_LONG; -#endif -#endif - -#ifndef PY_LONG_DOUBLE -typedef long double PY_LONG_DOUBLE; -#endif - -// FIXME: We should not duplicate these definitions here and in CppInterOp.h -// The current setup relies on finding an identical symbol definition in -// libcppjitbackend.so which is fragile and requires updating both locations -// when changing. Ideally we should have the ability to set/get the template arg -// info provided through some factory methods in CppInterOp API, so the clients -// can rely completely on opaque pointers like we do for the rest of the -// argument types. -struct TemplateArgInfo { - void* m_Type; - const char* m_IntegralValue; - TemplateArgInfo(void* type, const char* integral_value = nullptr) - : m_Type(type), m_IntegralValue(integral_value) {} -}; - -namespace Cpp { -using TemplateArgInfo = ::TemplateArgInfo; - -struct DeclRef { - void* data; - DeclRef() : data(nullptr) {} - DeclRef(void* P) : data(P) {} - DeclRef(decltype(nullptr)) : data(nullptr) {} - explicit operator bool() const { return data != nullptr; } - friend bool operator==(DeclRef a, DeclRef b) { return a.data == b.data; } - friend bool operator!=(DeclRef a, DeclRef b) { return !(a == b); } -}; - -struct TypeRef { - void* data; - TypeRef() : data(nullptr) {} - TypeRef(void* P) : data(P) {} - TypeRef(decltype(nullptr)) : data(nullptr) {} - explicit operator bool() const { return data != nullptr; } - friend bool operator==(TypeRef a, TypeRef b) { return a.data == b.data; } - friend bool operator!=(TypeRef a, TypeRef b) { return !(a == b); } -}; - -struct FuncRef { - void* data; - FuncRef() : data(nullptr) {} - FuncRef(void* P) : data(P) {} - FuncRef(decltype(nullptr)) : data(nullptr) {} - explicit operator bool() const { return data != nullptr; } - friend bool operator==(FuncRef a, FuncRef b) { return a.data == b.data; } - friend bool operator!=(FuncRef a, FuncRef b) { return !(a == b); } -}; - -struct ObjectRef { - void* data; - ObjectRef() : data(nullptr) {} - ObjectRef(void* P) : data(P) {} - ObjectRef(decltype(nullptr)) : data(nullptr) {} - explicit operator bool() const { return data != nullptr; } - friend bool operator==(ObjectRef a, ObjectRef b) { return a.data == b.data; } - friend bool operator!=(ObjectRef a, ObjectRef b) { return !(a == b); } -}; -} // namespace Cpp - -template <> struct std::hash { - std::size_t operator()(const Cpp::DeclRef& obj) const { - return std::hash{}(obj.data); - } -}; -template <> struct std::hash { - std::size_t operator()(const Cpp::TypeRef& obj) const { - return std::hash{}(obj.data); - } -}; -template <> struct std::hash { - std::size_t operator()(const Cpp::FuncRef& obj) const { - return std::hash{}(obj.data); - } -}; -template <> struct std::hash { - std::size_t operator()(const Cpp::ObjectRef& obj) const { - return std::hash{}(obj.data); - } -}; - -namespace cppjit::interop { -typedef Cpp::DeclRef TCppScope_t; -typedef Cpp::TypeRef TCppType_t; -typedef Cpp::ObjectRef TCppObject_t; -typedef Cpp::FuncRef TCppMethod_t; -typedef size_t TCppIndex_t; -typedef void* TCppFuncAddr_t; - -// direct interpreter access ------------------------------------------------- -CPPJIT_IMPORT -bool Compile(const std::string& code, bool silent = false); -CPPJIT_IMPORT -std::string ToString(TCppScope_t klass, TCppObject_t obj); - -// name to opaque C++ scope representation ----------------------------------- -CPPJIT_IMPORT -std::string ResolveName(const std::string& cppitem_name); -CPPJIT_IMPORT -TCppType_t ResolveType(TCppType_t cppitem_name); -CPPJIT_IMPORT -TCppType_t ResolveEnumReferenceType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t ResolveEnumPointerType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t GetRealType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t GetPointerType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t GetReferencedType(TCppType_t type, bool rvalue = false); -CPPJIT_IMPORT -std::string ResolveEnum(TCppScope_t enum_scope); -CPPJIT_IMPORT -bool IsLValueReferenceType(TCppType_t type); -CPPJIT_IMPORT -bool IsRValueReferenceType(TCppType_t type); -CPPJIT_IMPORT -bool IsClassType(TCppType_t type); -CPPJIT_IMPORT -bool IsIntegerType(TCppType_t type, bool* is_signed = nullptr); -CPPJIT_IMPORT -bool IsPointerType(TCppType_t type); -CPPJIT_IMPORT -bool IsFunctionPointerType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t GetType(const std::string& name, bool enable_slow_lookup = false); -CPPJIT_IMPORT -bool AppendTypesSlow(const std::string& name, - std::vector& types, - interop::TCppScope_t parent = nullptr); -CPPJIT_IMPORT -TCppType_t GetComplexType(const std::string& element_type); -CPPJIT_IMPORT -TCppScope_t GetScope(const std::string& scope_name, - TCppScope_t parent_scope = TCppScope_t{}); -CPPJIT_IMPORT -TCppScope_t GetUnderlyingScope(TCppScope_t scope); -CPPJIT_IMPORT -TCppScope_t GetFullScope(const std::string& scope_name); -CPPJIT_IMPORT -TCppScope_t GetTypeScope(TCppScope_t klass); -CPPJIT_IMPORT -TCppScope_t GetNamed(const std::string& scope_name, - TCppScope_t parent_scope = TCppScope_t{}); -CPPJIT_IMPORT -TCppScope_t GetParentScope(TCppScope_t scope); -CPPJIT_IMPORT -TCppScope_t GetScopeFromType(TCppType_t type); -CPPJIT_IMPORT -TCppType_t GetTypeFromScope(TCppScope_t klass); -CPPJIT_IMPORT -TCppScope_t GetGlobalScope(); -CPPJIT_IMPORT -TCppScope_t GetActualClass(TCppScope_t klass, TCppObject_t obj); -CPPJIT_IMPORT -size_t SizeOf(TCppScope_t klass); -CPPJIT_IMPORT -size_t SizeOfType(TCppType_t type); - -CPPJIT_IMPORT -bool IsBuiltin(const std::string& type_name); - -CPPJIT_IMPORT -bool IsBuiltin(TCppType_t type); - -CPPJIT_IMPORT -bool IsComplete(TCppScope_t type); - -// memory management --------------------------------------------------------- -CPPJIT_IMPORT -TCppObject_t Allocate(TCppScope_t scope); -CPPJIT_IMPORT -void Deallocate(TCppScope_t scope, TCppObject_t instance); -CPPJIT_IMPORT -TCppObject_t Construct(TCppScope_t scope, void* arena = nullptr); -CPPJIT_IMPORT -void Destruct(TCppScope_t scope, TCppObject_t instance); - -// method/function dispatching ----------------------------------------------- -CPPJIT_IMPORT -void CallV(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -unsigned char CallB(TCppMethod_t method, TCppObject_t self, size_t nargs, - void* args); -CPPJIT_IMPORT -char CallC(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -short CallH(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -int CallI(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -long CallL(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -PY_LONG_LONG CallLL(TCppMethod_t method, TCppObject_t self, size_t nargs, - void* args); -CPPJIT_IMPORT -float CallF(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -double CallD(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -PY_LONG_DOUBLE CallLD(TCppMethod_t method, TCppObject_t self, size_t nargs, - void* args); - -CPPJIT_IMPORT -void* CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args); -CPPJIT_IMPORT -char* CallS(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args, - size_t* length); -CPPJIT_IMPORT -TCppObject_t CallConstructor(TCppMethod_t method, TCppScope_t klass, - size_t nargs, void* args); -CPPJIT_IMPORT -void CallDestructor(TCppScope_t type, TCppObject_t self); -CPPJIT_IMPORT -TCppObject_t CallO(TCppMethod_t method, TCppObject_t self, size_t nargs, - void* args, TCppType_t result_type); - -CPPJIT_IMPORT -TCppFuncAddr_t GetFunctionAddress(TCppMethod_t method, - bool check_enabled = true); - -// handling of function argument buffer -------------------------------------- -CPPJIT_IMPORT -void* AllocateFunctionArgs(size_t nargs); -CPPJIT_IMPORT -void DeallocateFunctionArgs(void* args); -CPPJIT_IMPORT -size_t GetFunctionArgSizeof(); -CPPJIT_IMPORT -size_t GetFunctionArgTypeoffset(); - -// scope reflection information ---------------------------------------------- -CPPJIT_IMPORT -bool IsNamespace(TCppScope_t scope); -CPPJIT_IMPORT -bool IsClass(TCppScope_t scope); -CPPJIT_IMPORT -bool IsTemplate(TCppScope_t scope); -CPPJIT_IMPORT -bool IsTemplateInstantiation(TCppScope_t scope); -CPPJIT_IMPORT -bool IsTypedefed(TCppScope_t scope); -CPPJIT_IMPORT -bool IsAbstract(TCppScope_t scope); -CPPJIT_IMPORT -bool IsEnumScope(TCppScope_t scope); -CPPJIT_IMPORT -bool IsEnumConstant(TCppScope_t scope); -CPPJIT_IMPORT -bool IsEnumType(TCppType_t type); -CPPJIT_IMPORT -bool IsAggregate(TCppScope_t type); -CPPJIT_IMPORT -bool IsDefaultConstructable(TCppScope_t scope); -CPPJIT_IMPORT -bool IsVariable(TCppScope_t scope); - -CPPJIT_IMPORT -void GetAllCppNames(TCppScope_t scope, std::set& cppnames); - -// namespace reflection information ------------------------------------------ -CPPJIT_IMPORT -std::vector GetUsingNamespaces(TCppScope_t); - -// class reflection information ---------------------------------------------- -CPPJIT_IMPORT -std::string GetFinalName(TCppScope_t type); -CPPJIT_IMPORT -std::string GetScopedFinalName(TCppScope_t type); -CPPJIT_IMPORT -bool HasVirtualDestructor(TCppScope_t type); -CPPJIT_IMPORT -TCppIndex_t GetNumBases(TCppScope_t klass); -CPPJIT_IMPORT -TCppIndex_t GetNumBasesLongestBranch(TCppScope_t klass); -CPPJIT_IMPORT -std::string GetBaseName(TCppScope_t klass, TCppIndex_t ibase); -CPPJIT_IMPORT -TCppScope_t GetBaseScope(TCppScope_t klass, TCppIndex_t ibase); -CPPJIT_IMPORT -bool IsSubclass(TCppScope_t derived, TCppScope_t base); -CPPJIT_IMPORT -bool IsSmartPtr(TCppScope_t klass); -CPPJIT_IMPORT -bool GetSmartPtrInfo(const std::string&, TCppScope_t* raw, TCppMethod_t* deref); -// calculate offsets between declared and actual type, up-cast: direction > 0; -// down-cast: direction < 0 -CPPJIT_IMPORT -ptrdiff_t GetBaseOffset(TCppScope_t derived, TCppScope_t base, - TCppObject_t address, int direction, - bool rerror = false); - -// method/function reflection information ------------------------------------ -CPPJIT_IMPORT -void GetClassMethods(TCppScope_t scope, std::vector& methods); -CPPJIT_IMPORT -std::vector GetMethodsFromName(TCppScope_t scope, - const std::string& name); -CPPJIT_IMPORT -std::string GetName(TCppScope_t); -CPPJIT_IMPORT -std::string GetFullName(TCppScope_t); -CPPJIT_IMPORT -TCppType_t GetMethodReturnType(TCppMethod_t); -CPPJIT_IMPORT -std::string GetMethodReturnTypeAsString(TCppMethod_t); -CPPJIT_IMPORT -TCppIndex_t GetMethodNumArgs(TCppMethod_t); -CPPJIT_IMPORT -TCppIndex_t GetMethodReqArgs(TCppMethod_t); -CPPJIT_IMPORT -std::string GetMethodArgName(TCppMethod_t, TCppIndex_t iarg); -CPPJIT_IMPORT -TCppType_t GetMethodArgType(TCppMethod_t, TCppIndex_t iarg); -CPPJIT_IMPORT -TCppIndex_t CompareMethodArgType(TCppMethod_t, TCppIndex_t iarg, - const std::string& req_type); -CPPJIT_IMPORT -std::string GetMethodArgTypeAsString(TCppMethod_t method, TCppIndex_t iarg); -CPPJIT_IMPORT -std::string GetMethodArgCanonTypeAsString(TCppMethod_t method, - TCppIndex_t iarg); -CPPJIT_IMPORT -std::string GetMethodArgDefault(TCppMethod_t, TCppIndex_t iarg); -CPPJIT_IMPORT -std::string GetMethodSignature(TCppMethod_t, bool show_formal_args, - TCppIndex_t max_args = (TCppIndex_t)-1); -// GetMethodPrototype is unused. -CPPJIT_IMPORT -std::string GetMethodPrototype(TCppMethod_t, bool show_formal_args); -CPPJIT_IMPORT -std::string GetDoxygenComment(TCppScope_t scope, bool strip_markers = true); -CPPJIT_IMPORT -bool IsConstMethod(TCppMethod_t); -// Templated method/function reflection information -// ------------------------------------ -CPPJIT_IMPORT -void GetTemplatedMethods(TCppScope_t scope, std::vector& methods); -CPPJIT_IMPORT -TCppIndex_t GetNumTemplatedMethods(TCppScope_t scope, - bool accept_namespace = false); -CPPJIT_IMPORT -std::string GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth); -CPPJIT_IMPORT -bool ExistsMethodTemplate(TCppScope_t scope, const std::string& name); -CPPJIT_IMPORT -bool IsTemplatedMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsStaticTemplate(TCppScope_t scope, const std::string& name); -CPPJIT_IMPORT -TCppMethod_t GetMethodTemplate(TCppScope_t scope, const std::string& name, - const std::string& proto); -CPPJIT_IMPORT -void GetClassOperators(interop::TCppScope_t klass, const std::string& opname, - std::vector& operators); -CPPJIT_IMPORT -TCppMethod_t GetGlobalOperator(TCppScope_t scope, const std::string& lc, - const std::string& rc, const std::string& op); - -// method properties --------------------------------------------------------- -CPPJIT_IMPORT -bool IsDeletedMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsPublicMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsProtectedMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsPrivateMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsConstructor(TCppMethod_t method); -CPPJIT_IMPORT -bool IsDestructor(TCppMethod_t method); -CPPJIT_IMPORT -bool IsStaticMethod(TCppMethod_t method); -CPPJIT_IMPORT -bool IsExplicit(TCppMethod_t method); - -// data member reflection information ---------------------------------------- -CPPJIT_IMPORT -void GetDatamembers(TCppScope_t scope, std::vector& datamembers); -CPPJIT_IMPORT -bool IsLambdaClass(TCppType_t type); -CPPJIT_IMPORT -TCppScope_t WrapLambdaFromVariable(TCppScope_t var); -CPPJIT_IMPORT -TCppMethod_t AdaptFunctionForLambdaReturn(TCppMethod_t fn); -CPPJIT_IMPORT -TCppType_t GetDatamemberType(TCppScope_t data); -CPPJIT_IMPORT -std::string GetDatamemberTypeAsString(TCppScope_t var); -CPPJIT_IMPORT -std::string GetTypeAsString(TCppType_t type); -CPPJIT_IMPORT -intptr_t GetDatamemberOffset(TCppScope_t var, TCppScope_t klass = nullptr); -CPPJIT_IMPORT -bool CheckDatamember(TCppScope_t scope, const std::string& name); - -// // data member properties -// ---------------------------------------------------- -CPPJIT_IMPORT -bool IsPublicData(TCppScope_t var); -CPPJIT_IMPORT -bool IsProtectedData(TCppScope_t var); -CPPJIT_IMPORT -bool IsPrivateData(TCppScope_t var); -CPPJIT_IMPORT -bool IsStaticDatamember(TCppScope_t var); -CPPJIT_IMPORT -bool IsConstVar(TCppScope_t var); -CPPJIT_IMPORT -TCppMethod_t ReduceReturnType(TCppMethod_t fn, TCppType_t reduce); -CPPJIT_IMPORT -std::vector GetDimensions(TCppType_t type); - -// enum properties ----------------------------------------------------------- -CPPJIT_IMPORT -std::vector GetEnumConstants(TCppScope_t scope); -CPPJIT_IMPORT -TCppType_t GetEnumConstantType(TCppScope_t scope); -CPPJIT_IMPORT -TCppIndex_t GetEnumDataValue(TCppScope_t scope); - -CPPJIT_IMPORT -TCppScope_t InstantiateTemplate(TCppScope_t tmpl, Cpp::TemplateArgInfo* args, - size_t args_size); - -CPPJIT_IMPORT -void DumpScope(TCppScope_t scope); -} // namespace cppjit::interop - -#endif // !CPYRT_CPPJIT_H diff --git a/src/interop/callcontext.h b/src/interop/callcontext.h index d0f04f9..5573dba 100644 --- a/src/interop/callcontext.h +++ b/src/interop/callcontext.h @@ -1,11 +1,23 @@ -#ifndef CPYRT_CALLCONTEXT_H -#define CPYRT_CALLCONTEXT_H +#ifndef CPPJIT_INTEROP_CALLCONTEXT_H +#define CPPJIT_INTEROP_CALLCONTEXT_H // Standard -#include +#include +#include + +// convention to pass flag for direct calls (similar to Python's vector calls) +#define DIRECT_CALL ((size_t)1 << (8 * sizeof(size_t) - 1)) namespace cppjit::cpyrt { +// small number that allows use of stack for argument passing +const int SMALL_ARGS_N = 8; + +// The shipped cpyrt/API.h carries an identical Parameter for JIT-side +// code, which cannot see this in-tree header; the shared CPYRT_PARAMETER +// guard keeps one definition per TU. Keep both copies identical. +#ifndef CPYRT_PARAMETER +#define CPYRT_PARAMETER // general place holder for function parameters struct Parameter { union Value { @@ -31,7 +43,8 @@ struct Parameter { void* fRef; char fTypeCode; }; +#endif // CPYRT_PARAMETER } // namespace cppjit::cpyrt -#endif // !CPYRT_CALLCONTEXT_H +#endif // !CPPJIT_INTEROP_CALLCONTEXT_H diff --git a/src/interop/cpp_cppjit.h b/src/interop/cppjit_interop.h similarity index 96% rename from src/interop/cpp_cppjit.h rename to src/interop/cppjit_interop.h index 5fb4be4..ca7c07e 100644 --- a/src/interop/cpp_cppjit.h +++ b/src/interop/cppjit_interop.h @@ -1,5 +1,5 @@ -#ifndef CPYRT_CPPJIT_H -#define CPYRT_CPPJIT_H +#ifndef CPPJIT_INTEROP_H +#define CPPJIT_INTEROP_H #include #include @@ -36,15 +36,6 @@ typedef unsigned long long PY_ULONG_LONG; typedef long double PY_LONG_DOUBLE; #endif -typedef cppjit::cpyrt::Parameter Parameter; - -// small number that allows use of stack for argument passing -const int SMALL_ARGS_N = 8; - -// convention to pass flag for direct calls (similar to Python's vector calls) -#define DIRECT_CALL ((size_t)1 << (8 * sizeof(size_t) - 1)) -static inline size_t CALL_NARGS(size_t nargs) { return nargs & ~DIRECT_CALL; } - namespace cppjit::interop { typedef Cpp::DeclRef TCppScope_t; typedef Cpp::TypeRef TCppType_t; @@ -402,4 +393,4 @@ RPY_EXPORTED void DumpScope(TCppScope_t scope); } // namespace cppjit::interop -#endif // !CPYRT_CPPJIT_H +#endif // !CPPJIT_INTEROP_H diff --git a/src/interop/interop_wrapper.cxx b/src/interop/interop_wrapper.cxx index 0b71747..cce30fa 100644 --- a/src/interop/interop_wrapper.cxx +++ b/src/interop/interop_wrapper.cxx @@ -8,11 +8,15 @@ #include "precommondefs.h" // This defines several system feature macros and should be included before any system header. // Bindings -#include "cpp_cppjit.h" +#include "cppjit_interop.h" using namespace cppjit; #include "callcontext.h" +typedef cppjit::cpyrt::Parameter Parameter; + +static inline size_t CALL_NARGS(size_t nargs) { return nargs & ~DIRECT_CALL; } + #ifndef _WIN32 #include #endif @@ -111,7 +115,7 @@ static InterOpPaths cppinterop_paths() { // The one place libclangCppInterOp is dlopen'd. static bool loadDispatchAPI(const InterOpPaths& Paths) { if (!Cpp::LoadDispatchAPI(Paths.Library.c_str())) { - std::cerr << "[cppjit-backend] Failed to load CppInterOp" << std::endl; + std::cerr << "[cppjit] Failed to load CppInterOp" << std::endl; return false; } return true; @@ -859,8 +863,8 @@ static inline bool WrapperCall(interop::TCppMethod_t method, size_t nargs, InterOpMutex.unlock(); bool runRelease = false; // const auto& fgen = /* is_direct ? faceptr.fDirect : */ faceptr; - if (nargs <= SMALL_ARGS_N) { - void* smallbuf[SMALL_ARGS_N]; + if (nargs <= cpyrt::SMALL_ARGS_N) { + void* smallbuf[cpyrt::SMALL_ARGS_N]; if (nargs) runRelease = copy_args(args, nargs, smallbuf); // CLING_CATCH_UNCAUGHT_ From 133da28801fb843be99da42c8a27243f443175a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kerem=20=C5=9Eahin?= Date: Sun, 30 Aug 2026 22:20:26 +0300 Subject: [PATCH 05/17] [test] Fix failures with parallel pytest runs (#49) Changed definition of a function to the test it is actually used, and added a missing import --- test/test_doc_features.py | 12 ++++++++---- test/test_lowlevel.py | 3 ++- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/test/test_doc_features.py b/test/test_doc_features.py index 9822605..70fa02e 100644 --- a/test/test_doc_features.py +++ b/test/test_doc_features.py @@ -142,10 +142,6 @@ class Abstract2 { return f(i1, i2); } -template -C multiply(A a, B b) { - return static_cast(a * b); -} //----- namespace Namespace { @@ -714,6 +710,14 @@ def test09_templated_function(self): import cppjit + cppjit.cppdef(""" + +template +C multiply(A a, B b) { +return static_cast(a * b); +} + +""") mul = cppjit.gbl.multiply assert "multiply" in cppjit.gbl.__dict__ diff --git a/test/test_lowlevel.py b/test/test_lowlevel.py index 0208a5f..bcc7ac3 100644 --- a/test/test_lowlevel.py +++ b/test/test_lowlevel.py @@ -61,13 +61,14 @@ def test03_memory(self): """Memory allocation and free-ing""" import cppjit + from cppjit import ll # regular C malloc/free mem = cppjit.gbl.malloc(16) cppjit.gbl.free(mem) # typed styles - mem = cppjit.ll.malloc[int](self.N) + mem = ll.malloc[int](self.N) assert len(mem) == self.N assert not mem.__cpp_array__ for i in range(self.N): From 6d89803d34c768f622ca31d255c3b797baf330d3 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Mon, 31 Aug 2026 15:36:42 +0200 Subject: [PATCH 06/17] [build] Lean install: ship single stripped libclangCppInterOp (#50) Drops wheel sizes by about half. Previously the entire install tree of CppInterOp was staged that included duplicate shared libs due to versioning. This is fixed by adding a stripped shared-lib option in CppInterOp, leveraged in this patch. --- CMakeLists.txt | 26 ++++++++++++-------------- cmake/AddCppInterOp.cmake | 10 ++++++++-- 2 files changed, 20 insertions(+), 16 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 50403dc..465d158 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ include(GNUInstallDirs) # 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) set(CPPINTEROP_GIT_REPOSITORY "https://github.com/compiler-research/CppInterOp.git" CACHE STRING "") -set(CPPINTEROP_GIT_TAG "8d624c621a4b95e36ff73ac708c85a768287478f" CACHE STRING "") +set(CPPINTEROP_GIT_TAG "9802d61921ad5688ae42e4e628d754fc1192244d" CACHE STRING "") set(CPPINTEROP_SOURCE_DIR "" CACHE PATH "Override default CppInterOp built by ExternalProject_Add, with a path to local CppInterOp source") @@ -101,7 +101,10 @@ if(_python_platlib) else() set(CPPINTEROP_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") endif() -set(CPPINTEROP_INSTALL_DIR "${CPPINTEROP_INSTALL_PREFIX}/cppjit/interop") + +# CppInterOp installs here; cppjit's own rules ship a subset, so the wheel +# owns every installed file. +set(CPPINTEROP_STAGE_DIR "${CMAKE_BINARY_DIR}/cppinterop-stage") # Include cmake for CppInterOp config and build using ExternalProject. include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/AddCppInterOp.cmake) @@ -134,7 +137,7 @@ target_include_directories(cppjit PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR}/src/cpyrt ${CMAKE_CURRENT_SOURCE_DIR}/src/interop - ${CPPINTEROP_INSTALL_DIR}/include + ${CPPINTEROP_STAGE_DIR}/include ${Python_INCLUDE_DIRS} ) @@ -164,17 +167,12 @@ install(TARGETS cppjit LIBRARY DESTINATION cppjit ) -# install CppInterOp libraries and headers -install(CODE " - file(GLOB _interop_libs \"${CPPINTEROP_INSTALL_DIR}/lib/libclangCppInterOp*\") - foreach(_lib \${_interop_libs}) - file(INSTALL \${_lib} DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/interop/lib) - endforeach() -") - -install(CODE " - file(INSTALL \"${CPPINTEROP_INSTALL_DIR}/include/\" DESTINATION \${CMAKE_INSTALL_PREFIX}/cppjit/interop/include) -") +install(DIRECTORY "${CPPINTEROP_STAGE_DIR}/lib/" + DESTINATION cppjit/interop/lib +) +install(DIRECTORY "${CPPINTEROP_STAGE_DIR}/include/" + DESTINATION cppjit/interop/include +) # ship the builtin headers of the build clang, laid out as a headers-only # resource dir: only include/ ships diff --git a/cmake/AddCppInterOp.cmake b/cmake/AddCppInterOp.cmake index 50c069e..be0fef2 100644 --- a/cmake/AddCppInterOp.cmake +++ b/cmake/AddCppInterOp.cmake @@ -22,7 +22,9 @@ function(cppjit_add_cppinterop) -DLLVM_DIR=${LLVM_DIR} -DCPPINTEROP_ENABLE_TESTING=${CPPJIT_ENABLE_CPPINTEROP_TESTS} -DBUILD_SHARED_LIBS=ON - -DCMAKE_INSTALL_PREFIX=${CPPINTEROP_INSTALL_DIR} + # The wheel ships a single unversioned library file. + -DCPPINTEROP_SHARED_LIBRARY_VERSIONING=OFF + -DCMAKE_INSTALL_PREFIX=${CPPINTEROP_STAGE_DIR} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_CXX_STANDARD=17 @@ -85,12 +87,16 @@ function(cppjit_add_cppinterop) set(_log_args "") endif() + # Install only the library and headers, not CppInterOp's full install tree. ExternalProject_Add(CppInterOp ${_source_args} PREFIX "${CMAKE_BINARY_DIR}/CppInterOp" CMAKE_ARGS ${_args} + # -stripped keeps .dynsym, so the dlsym-based dispatch still resolves. + INSTALL_COMMAND ${CMAKE_COMMAND} --build + --target install-clangCppInterOp-stripped install-cppinterop-headers BUILD_BYPRODUCTS - "${CPPINTEROP_INSTALL_DIR}/lib/libclangCppInterOp${CMAKE_SHARED_LIBRARY_SUFFIX}" + "${CPPINTEROP_STAGE_DIR}/lib/libclangCppInterOp${CMAKE_SHARED_LIBRARY_SUFFIX}" ${_log_args} ) From ab31d05b25596a43713a2d7e8ecdba346ec73e5c Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Mon, 31 Aug 2026 18:23:31 +0200 Subject: [PATCH 07/17] [interop] Silence unused-parameter warnings. NFC (#53) --- src/interop/interop_wrapper.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/interop/interop_wrapper.cxx b/src/interop/interop_wrapper.cxx index cce30fa..1b5b0eb 100644 --- a/src/interop/interop_wrapper.cxx +++ b/src/interop/interop_wrapper.cxx @@ -1254,8 +1254,8 @@ std::string interop::GetMethodArgDefault(TCppMethod_t method, } interop::TCppIndex_t -interop::CompareMethodArgType(TCppMethod_t /*method*/, TCppIndex_t iarg, - const std::string& req_type) { +interop::CompareMethodArgType(TCppMethod_t /*method*/, TCppIndex_t /*iarg*/, + const std::string& /*req_type*/) { // if (method) { // TFunction* f = m2f(method); // TMethodArg* arg = (TMethodArg From b48635e0a280f89080950031e6134928bf300093 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Mon, 31 Aug 2026 19:56:51 +0200 Subject: [PATCH 08/17] [cpyrt] Clear stale Python errors before C API calls (#52) [cpyrt] Clear the error indicator only where a call failed A debug build of CPython asserts when a C API call is made with the error indicator already set, so the __cpp_cross__ annotation, the meta_setattro fallthrough to tp_setattro, and the VectorData alias need it cleared. Clear it only on the failing path: AddToClass reports failure, and the two CPPScope sites can test the value they just produced, so an error raised elsewhere still propagates. meta_getattro returns a new reference; release it instead of leaking it. --- src/cpyrt/CPPScope.cxx | 19 ++++++++++++++----- src/cpyrt/Pythonize.cxx | 3 ++- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/src/cpyrt/CPPScope.cxx b/src/cpyrt/CPPScope.cxx index fded0d5..b58469d 100644 --- a/src/cpyrt/CPPScope.cxx +++ b/src/cpyrt/CPPScope.cxx @@ -274,10 +274,14 @@ static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds) { // also signals that this is a cross-inheritance class) PyObject* bname = cpyrt_PyText_FromString( interop::GetBaseName(result->fCppType, 0).c_str()); - if (PyObject_SetAttrString((PyObject*)result, "__cpp_cross__", - bname) == -1) + if (!bname) PyErr_Clear(); - Py_DECREF(bname); + else { + if (PyObject_SetAttrString((PyObject*)result, "__cpp_cross__", + bname) == -1) + PyErr_Clear(); + Py_DECREF(bname); + } } } else if (sz == (Py_ssize_t)-1) PyErr_Clear(); @@ -571,8 +575,13 @@ static int meta_setattro(PyObject* pyclass, PyObject* pyname, PyObject* pyval) { if (((CPPScope*)pyclass)->fFlags & CPPScope::kIsNamespace && !cpyrt::CPPDataMember_Check(pyval) && !cpyrt::CPPScope_Check(pyval)) { std::string name = cpyrt_PyText_AsString(pyname); - if (interop::GetNamed(name, ((CPPScope*)pyclass)->fCppType)) - meta_getattro(pyclass, pyname); // triggers creation + if (interop::GetNamed(name, ((CPPScope*)pyclass)->fCppType)) { + PyObject* attr = meta_getattro(pyclass, pyname); // triggers creation + if (!attr) + PyErr_Clear(); + else + Py_DECREF(attr); + } } return PyType_Type.tp_setattro(pyclass, pyname, pyval); diff --git a/src/cpyrt/Pythonize.cxx b/src/cpyrt/Pythonize.cxx index 3e6b874..e14067c 100644 --- a/src/cpyrt/Pythonize.cxx +++ b/src/cpyrt/Pythonize.cxx @@ -1898,7 +1898,8 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { METH_VARARGS | METH_KEYWORDS); // data with size - Utility::AddToClass(pyclass, "__real_data", "data"); + if (!Utility::AddToClass(pyclass, "__real_data", "data")) + PyErr_Clear(); // no 'data' method to alias Utility::AddToClass(pyclass, "data", (PyCFunction)VectorData); // numpy array conversion From 94c2728411d644bafb93ce6ff59ce76aa5efc638 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Mon, 31 Aug 2026 21:02:24 +0200 Subject: [PATCH 09/17] Support building wheels for manylinux and OSX (#22) * [test] Find eigen and boost under the Homebrew and MacPorts prefixes * [ci] Build and test manylinux and macOS arm64 wheels --- .github/wheel_smoke.py | 20 ++++++ .github/workflows/wheels.yml | 114 +++++++++++++++++++++++++++++++++++ pyproject.toml | 23 ++++++- test/test_boost.py | 30 +++++++-- test/test_eigen.py | 2 + 5 files changed, 184 insertions(+), 5 deletions(-) create mode 100644 .github/wheel_smoke.py create mode 100644 .github/workflows/wheels.yml diff --git a/.github/wheel_smoke.py b/.github/wheel_smoke.py new file mode 100644 index 0000000..dd3267c --- /dev/null +++ b/.github/wheel_smoke.py @@ -0,0 +1,20 @@ +"""Wheel smoke test, run from a clean venv by cibuildwheel's test step: +libcppjit.so must locate libclangCppInterOp relative to its own path (the +build tree is gone by test time), and the template instantiation plus the +header check prove the shipped include tree.""" + +import os + +import cppjit + +cppjit.cppdef("int wheel_smoke(int x) { return x + 1; }") +assert cppjit.gbl.wheel_smoke(41) == 42 + +v = cppjit.gbl.std.vector["int"]() +v.push_back(7) +assert v[0] == 7 + +api = os.path.join( + os.path.dirname(cppjit.__file__), "interop", "include", "cpyrt", "API.h" +) +assert os.path.exists(api), api diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml new file mode 100644 index 0000000..a7b3cb4 --- /dev/null +++ b/.github/workflows/wheels.yml @@ -0,0 +1,114 @@ +name: Wheels + +# Build the wheels (cibuildwheel; config in pyproject.toml) and the sdist +# as artifacts. setup-recipe stages the llvm-wheel toolchain at /opt/llvm; +# linux mounts it into the build container, the same manylinux_2_28 image +# the toolchain was built on. + +on: + workflow_dispatch: + pull_request: + paths: + - '.github/workflows/wheels.yml' + - '.github/wheel_smoke.py' + - 'pyproject.toml' + - 'CMakeLists.txt' + - 'cmake/**' + - 'src/interop/**' + - 'python/cppjit/_cpython_cppjit.py' + push: + tags: ['v*'] + schedule: + - cron: '30 4 * * 1' + +permissions: + contents: read + +concurrency: + group: wheels-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +jobs: + wheels: + name: wheels ${{ matrix.label }} + strategy: + fail-fast: false + matrix: + include: + - { os: ubuntu-24.04, label: manylinux-x86_64, arch: x86_64 } + - { os: macos-26, label: macosx-arm64, arch: arm64 } + runs-on: ${{ matrix.os }} + + steps: + - uses: actions/checkout@v7 + + # ref pins the recipe content the cache key is computed from. + - uses: compiler-research/ci-workflows/actions/setup-recipe@main + id: llvm + with: + recipe: llvm-wheel + version: '21.1.8' + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} + ref: b760e4c171961786b7b20e2cc514302df5373eef + + - name: Stage the toolchain at /opt/llvm + env: + RECIPE_PATH: ${{ steps.llvm.outputs.path }} + run: sudo mv "$RECIPE_PATH" /opt/llvm + + - uses: pypa/cibuildwheel@v4.2.0 + + - uses: actions/upload-artifact@v7 + with: + name: wheels-${{ matrix.label }} + path: wheelhouse/*.whl + + sdist: + name: sdist + runs-on: ubuntu-24.04 + steps: + - uses: actions/checkout@v7 + + - run: pipx run build --sdist + + - uses: actions/upload-artifact@v7 + with: + name: sdist + path: dist/*.tar.gz + + # Run the full suite on a plain runner, outside the manylinux + # container the wheel was built in. + test-wheel: + name: test wheel (full suite) + needs: wheels + runs-on: ubuntu-24.04 + steps: + - uses: actions/checkout@v7 + + - uses: actions/setup-python@v7 + with: + python-version: '3.12' + + - uses: actions/download-artifact@v8 + with: + name: wheels-manylinux-x86_64 + path: wheelhouse + + - name: Install the test suite's native deps + # test_eigen/test_boost need them; the CI cells install the same pair. + run: sudo apt-get -q update && sudo apt-get -y install libeigen3-dev libboost-dev + + - name: Install the wheel and the test requirements + run: python -m pip install wheelhouse/cppjit-*cp312*.whl -r requirements.txt + + - name: Smoke the wheel outside pytest + run: python -X faulthandler .github/wheel_smoke.py + + - name: Run the test suite against the installed wheel + env: + CPPINTEROP_EXTRA_INTERPRETER_ARGS: -std=c++20 + run: | + cd test + make -j$(nproc) PYTHON=python + python -m pytest -ra diff --git a/pyproject.toml b/pyproject.toml index 5308b63..63d0fc9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ build-backend = "scikit_build_core.build" name = "cppjit" dynamic = ["version"] description = "CppJIT: fast and automatic Python-C++ interoperability" -license = {text = "LBNL BSD"} +license = "BSD-3-Clause-LBNL" requires-python = ">=3.12" authors = [ {name = "Aaron Jomy"}, @@ -21,6 +21,7 @@ maintainers = [ ] [tool.scikit-build] +minimum-version = "build-system.requires" wheel.install-dir = "." wheel.packages = ["python/cppjit"] cmake.build-type = "Release" @@ -30,6 +31,26 @@ provider = "scikit_build_core.metadata.regex" field = "version" input = "python/cppjit/_version.py" +[tool.cibuildwheel] +build = ["cp312-*", "cp313-*", "cp314-*"] +skip = ["*-musllinux*"] +build-verbosity = 1 +test-sources = ["test", "requirements.txt", ".github/wheel_smoke.py"] +test-command = "python .github/wheel_smoke.py" + +[tool.cibuildwheel.linux] +archs = ["x86_64"] +manylinux-x86_64-image = "manylinux_2_28" +# /opt/llvm is staged on the runner by wheels.yml. +container-engine = { name = "docker", create-args = ["--volume=/opt/llvm:/opt/llvm"] } +environment = { CMAKE_ARGS = "-DLLVM_DIR=/opt/llvm/lib/cmake/llvm -DClang_DIR=/opt/llvm/lib/cmake/clang" } + +[tool.cibuildwheel.macos] +archs = ["arm64"] +before-test = "brew install eigen boost" +test-command = "python -m pip install -r requirements.txt && python .github/wheel_smoke.py && cd test && make -j$(sysctl -n hw.ncpu) PYTHON=python && CPPINTEROP_EXTRA_INTERPRETER_ARGS=-std=c++20 python -m pytest -ra" +environment = { CMAKE_ARGS = "-DLLVM_DIR=/opt/llvm/lib/cmake/llvm -DClang_DIR=/opt/llvm/lib/cmake/clang", MACOSX_DEPLOYMENT_TARGET = "14.0" } + [tool.pytest.ini_options] testpaths = ["test"] pythonpath = ["test"] diff --git a/test/test_boost.py b/test/test_boost.py index 3680641..5d51cae 100644 --- a/test/test_boost.py +++ b/test/test_boost.py @@ -3,12 +3,30 @@ from pytest import mark, raises, skip from support import IS_MAC_ARM, IS_MAC_X86 -noboost = False -if not ( +# /usr/include and /usr/local/include are on the compiler's default search +# path; the Homebrew (arm64) and MacPorts prefixes are not, so a hit there +# is remembered and added explicitly before the first include. +boost_extra_inc = None +noboost = not ( os.path.exists(os.path.join(os.path.sep, "usr", "include", "boost")) or os.path.exists(os.path.join(os.path.sep, "usr", "local", "include", "boost")) -): - noboost = True +) +if noboost: + for p in ( + os.path.join(os.path.sep, "opt", "homebrew", "include"), + os.path.join(os.path.sep, "opt", "local", "include"), + ): + if os.path.exists(os.path.join(p, "boost")): + boost_extra_inc = p + noboost = False + break + + +def add_boost_include_path(): + if boost_extra_inc is not None: + import cppjit + + cppjit.add_include_path(boost_extra_inc) @mark.skipif(noboost == True, reason="boost not found") @@ -16,6 +34,7 @@ class TestBOOSTANY: def setup_class(cls): import cppjit + add_boost_include_path() cppjit.include("boost/any.hpp") @mark.skipif((IS_MAC_ARM or IS_MAC_X86), reason="Fails to include boost on OS X") @@ -76,6 +95,7 @@ class TestBOOSTOPERATORS: def setup_class(cls): import cppjit + add_boost_include_path() cppjit.include("boost/operators.hpp") def test01_ordered(self): @@ -101,6 +121,7 @@ class TestBOOSTVARIANT: def setup_class(cls): import cppjit + add_boost_include_path() cppjit.include("boost/variant/variant.hpp") cppjit.include("boost/variant/get.hpp") @@ -147,6 +168,7 @@ class TestBOOSTERASURE: def setup_class(cls): import cppjit + add_boost_include_path() cppjit.include("boost/type_erasure/any.hpp") cppjit.include("boost/type_erasure/member.hpp") cppjit.include("boost/mpl/vector.hpp") diff --git a/test/test_eigen.py b/test/test_eigen.py index ab33c34..88a0772 100644 --- a/test/test_eigen.py +++ b/test/test_eigen.py @@ -5,6 +5,8 @@ inc_paths = [ os.path.join(os.path.sep, "usr", "include"), os.path.join(os.path.sep, "usr", "local", "include"), + os.path.join(os.path.sep, "opt", "homebrew", "include"), # Homebrew on arm64 + os.path.join(os.path.sep, "opt", "local", "include"), # MacPorts ] eigen_path = None From 6ac8260063c828ee7525cc054c5bd9b64b75600c Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Mon, 31 Aug 2026 21:02:42 +0200 Subject: [PATCH 10/17] [cpyrt] Reuse InitializerListConverter element converters (#54) SetArg() created an element converter per call and appended it to fConverters, but Clear() frees only fBuffer, so the vector grew without bound across repeated std::initializer_list conversions. Create each element converter once, on first use of its index, and reuse it. --- src/cpyrt/Converters.cxx | 8 ++++---- test/test_leakcheck.py | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/cpyrt/Converters.cxx b/src/cpyrt/Converters.cxx index 31ab848..c647696 100644 --- a/src/cpyrt/Converters.cxx +++ b/src/cpyrt/Converters.cxx @@ -3186,7 +3186,9 @@ bool cpyrt::InitializerListConverter::SetArg(PyObject* pyobject, PyObject* item = PySequence_GetItem(pyobject, i); bool convert_ok = false; if (item) { - Converter* converter = CreateConverter(fValueTypeName); + if (i >= fConverters.size()) + fConverters.emplace_back(CreateConverter(fValueTypeName)); + Converter* converter = fConverters[i]; if (!converter) { if (CPPInstance_Check(item)) { // by convention, use byte copy @@ -3208,10 +3210,8 @@ bool cpyrt::InitializerListConverter::SetArg(PyObject* pyobject, .c_str()); entries += 1; } - if (memloc) { + if (memloc) convert_ok = converter->ToMemory(item, memloc); - } - fConverters.emplace_back(converter); } Py_DECREF(item); diff --git a/test/test_leakcheck.py b/test/test_leakcheck.py index ea21184..6813f29 100644 --- a/test/test_leakcheck.py +++ b/test/test_leakcheck.py @@ -282,3 +282,21 @@ def wrapped_list_by_value(): ns.leak_list = wrapped_list_by_value self.check_func(ns, "leak_list") + + def test09_initializer_list_argument(self): + """Leak check of passing a list as an std::initializer_list argument""" + + import cppjit + + cppjit.cppdef("""\ + namespace LeakCheck { + int sum_il(std::initializer_list l) { + int s = 0; + for (auto i : l) s += i; + return s; + } + }""") + + ns = cppjit.gbl.LeakCheck + + self.check_func(ns, "sum_il", [1, 2, 3]) From 8e1f14085df3d5a6e3ea0c10b95b944a8e2bed72 Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Tue, 1 Sep 2026 13:35:19 +0200 Subject: [PATCH 11/17] [test] Improve pytest infrastructure, markers and xdist support (#51) * Serialize and atomize test dictionary builds * Force loadfile scheduling for distributed test runs * Normalize the xfail marker keyword order * Correct the xfail markers and add missing reasons * Add the --run-crashing-xfails collection option * Enable strict xfail * Drop xfail markers that no longer fail on macOS and cling * Make the span tests include their own header --- .gitignore | 2 ++ pyproject.toml | 1 + test/Makefile | 7 ++-- test/conftest.py | 66 +++++++++++++++++++++++++++++++++++ test/support.py | 27 ++++++++++---- test/test_advancedcpp.py | 9 +++-- test/test_api.py | 4 +-- test/test_basic_api.py | 9 ++--- test/test_boost.py | 4 +-- test/test_concurrent.py | 5 ++- test/test_conversions.py | 2 +- test/test_cpp11features.py | 14 ++++---- test/test_crossinheritance.py | 42 +++++++++------------- test/test_datatypes.py | 9 ++--- test/test_doc_features.py | 29 ++++++--------- test/test_fragile.py | 21 +++++++++-- test/test_lowlevel.py | 4 +-- test/test_numba.py | 2 +- test/test_overloads.py | 7 +--- test/test_pythonization.py | 4 +-- test/test_regression.py | 22 +++++------- test/test_stltypes.py | 47 ++++++++++--------------- test/test_streams.py | 4 +-- test/test_templates.py | 15 ++++---- 24 files changed, 201 insertions(+), 155 deletions(-) create mode 100644 test/conftest.py diff --git a/.gitignore b/.gitignore index 2013091..65e307c 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,8 @@ __pycache__/ # Built test dictionaries and extension modules *.so +*.so.*.tmp +*Dict.lock # Packaging build/ diff --git a/pyproject.toml b/pyproject.toml index 63d0fc9..b9a2821 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -54,6 +54,7 @@ environment = { CMAKE_ARGS = "-DLLVM_DIR=/opt/llvm/lib/cmake/llvm -DClang_DIR=/o [tool.pytest.ini_options] testpaths = ["test"] pythonpath = ["test"] +xfail_strict = true [tool.ruff] show-fixes = true diff --git a/test/Makefile b/test/Makefile index e07e775..7f1433e 100644 --- a/test/Makefile +++ b/test/Makefile @@ -29,8 +29,9 @@ ifeq ($(PLATFORM),Darwin) cppflags+=-dynamiclib -single_module -undefined dynamic_lookup -Wno-delete-non-virtual-dtor endif -cpp/%Dict.so: cpp/%.cxx - $(CXX) $(cppflags) -shared -o $@ $^ +# a worker can load the library while another rebuilds it, so publish it whole +cpp/%Dict.so: cpp/%.cxx cpp/%.h + $(CXX) $(cppflags) -shared -o $@.$$$$.tmp $< && mv -f $@.$$$$.tmp $@ # convenience: `make datatypesDict.so` builds cpp/datatypesDict.so %Dict.so: cpp/%Dict.so ; @@ -41,4 +42,4 @@ test: pytest test_*.py clean: - -rm -f $(dicts) + -rm -f $(dicts) cpp/*.tmp cpp/*.lock diff --git a/test/conftest.py b/test/conftest.py new file mode 100644 index 0000000..525f071 --- /dev/null +++ b/test/conftest.py @@ -0,0 +1,66 @@ +"""Suite-wide pytest infrastructure. + +Tests within a file share interpreter state (cppdefs, loaded dictionaries, +pythonizations), so distributed runs must keep whole files on one worker. +""" + +import pytest + + +def pytest_addoption(parser): + parser.addoption( + "--run-crashing-xfails", + action="store_true", + default=False, + help="run xfail(run=False) crash-class tests; a pass is a strict xpass", + ) + + +def _applies_here(mark): + """Whether a mark's conditions hold; pytest evaluates string ones itself.""" + + conditions = list(mark.args[:1]) + if "condition" in mark.kwargs: + conditions.append(mark.kwargs["condition"]) + return all(True if isinstance(c, str) else bool(c) for c in conditions) + + +def pytest_collection_modifyitems(config, items): + if not config.getoption("--run-crashing-xfails"): + return + # Keep only the crash markers that claim this platform, and let them run: + # the marker stays, so one that stopped crashing reports as a strict + # xpass. The rest are deselected; they would only add state the real + # suite never has. + selected, deselected = [], [] + for item in items: + crashing = [ + m + for m in item.own_markers + if m.name == "xfail" and m.kwargs.get("run") is False and _applies_here(m) + ] + if not crashing: + deselected.append(item) + continue + item.own_markers = [ + pytest.mark.xfail(*m.args, **{**m.kwargs, "run": True}).mark + if m in crashing + else m + for m in item.own_markers + ] + selected.append(item) + if deselected: + config.hook.pytest_deselected(items=deselected) + items[:] = selected + + +def pytest_configure(config): + # -n implies --dist load; every mode finer than per-file is remapped + # ("each" and "no" already keep files whole). + if config.getoption("numprocesses", None) and config.getoption("dist", "no") in ( + "load", + "worksteal", + "loadscope", + "loadgroup", + ): + config.option.dist = "loadfile" diff --git a/test/support.py b/test/support.py index 5d1e74e..de2532d 100644 --- a/test/support.py +++ b/test/support.py @@ -6,6 +6,11 @@ import py +try: + import fcntl +except ImportError: # Windows: no concurrent make workflow to serialize + fcntl = None + currpath = py.path.local(__file__).dirpath() @@ -13,13 +18,21 @@ def setup_make(targetname): if os.getenv("CPPJIT_TEST_SKIP_MAKE", False): return - popen = subprocess.Popen( - ["make", targetname + "Dict.so"], - cwd=str(currpath), - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT, - ) - stdout, _ = popen.communicate() + # several files share a dictionary, so workers race make for it; the lock + # is per target to keep unrelated builds parallel + lockf = open(str(currpath.join("cpp", targetname + "Dict.lock")), "a") + try: + if fcntl is not None: + fcntl.flock(lockf, fcntl.LOCK_EX) + popen = subprocess.Popen( + ["make", targetname + "Dict.so"], + cwd=str(currpath), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + ) + stdout, _ = popen.communicate() + finally: + lockf.close() if popen.returncode: raise OSError("'make' failed:\n%s" % (stdout,)) diff --git a/test/test_advancedcpp.py b/test/test_advancedcpp.py index 2d0f469..9d754e7 100644 --- a/test/test_advancedcpp.py +++ b/test/test_advancedcpp.py @@ -643,7 +643,7 @@ def test15_template_instantiation_with_vector_of_float(self): b.m_b.push_back(i) assert round(b.m_b[i], 5) == float(i) - @mark.xfail + @mark.xfail(reason="templated free function returns a string proxy, not str") def test16_template_global_functions(self): """Test template global function lookup and calls""" @@ -708,7 +708,6 @@ def test19_comparator(self): assert a.__eq__(a) == False assert b.__eq__(b) == False - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test20_overload_order_with_proper_return(self): """Test return type against proper overload w/ const and covariance""" @@ -717,7 +716,7 @@ def test20_overload_order_with_proper_return(self): assert cppjit.gbl.overload_one_way().gime() == 1 assert cppjit.gbl.overload_the_other_way().gime() == "aap" - @mark.xfail(run=not IS_VALGRIND) + @mark.xfail(condition=IS_VALGRIND, run=False, reason="hangs under valgrind") def test21_access_to_global_variables(self): """Access global_variables_and_pointers""" @@ -752,8 +751,8 @@ def test21_access_to_global_variables(self): assert len(cppjit.gbl.gtestv2) == 1 @mark.xfail( - run=False, condition=IS_MAC_ARM, + run=False, reason="Crashes with exception not being caught on Apple Silicon", ) def test22_exceptions(self): @@ -779,7 +778,7 @@ def test22_exceptions(self): caught = True assert caught == True - @mark.xfail + @mark.xfail(reason="using-declared overloads expose the base class signature") def test23_using(self): """Accessibility of using declarations""" diff --git a/test/test_api.py b/test/test_api.py index c52fc4c..f6f4926 100644 --- a/test/test_api.py +++ b/test/test_api.py @@ -67,7 +67,7 @@ class APICheck2 { m2 = API.Instance_FromVoidPtr(voidp, "APICheck2") assert m is m2 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test04_custom_converter(self): """Custom type converter""" @@ -146,7 +146,7 @@ class APICheck3Converter : public cppjit::cpyrt::Converter { assert type(gA3b) == cppjit.gbl.APICheck3 assert not gA3b.wasFromMemoryCalled() - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test05_custom_executor(self): """Custom type executor""" diff --git a/test/test_basic_api.py b/test/test_basic_api.py index 9e9fdbe..10e2e81 100644 --- a/test/test_basic_api.py +++ b/test/test_basic_api.py @@ -2,8 +2,8 @@ import tempfile import py -from pytest import mark, raises -from support import IS_MAC, setup_make +from pytest import raises +from support import setup_make # reuse the example01 currpath = py.path.local(__file__).dirpath() @@ -15,7 +15,6 @@ def setup_module(mod): class TestBASICAPI: - @mark.xfail(IS_MAC, reason="evaluate is broken on macos") def test01_evaluate(self): import cppjit @@ -34,10 +33,6 @@ def test01_evaluate(self): x = 42 assert cppjit.evaluate(str(x)) == x - @mark.xfail( - IS_MAC, - reason="unidentified IsDebugOutputEnabled issue on macos, also failing in test_fragile", - ) def test02_cppdef(self): import cppjit diff --git a/test/test_boost.py b/test/test_boost.py index 5d51cae..bba20a1 100644 --- a/test/test_boost.py +++ b/test/test_boost.py @@ -50,7 +50,7 @@ def test01_any_class(self): assert std.list[any] - @mark.xfail(run=False) + @mark.xfail(run=False, reason="boost::any casting crashes") def test02_any_usage(self): """boost::any assignment and casting""" @@ -125,7 +125,7 @@ def setup_class(cls): cppjit.include("boost/variant/variant.hpp") cppjit.include("boost/variant/get.hpp") - @mark.xfail(run=False) + @mark.xfail(run=False, reason="boost::variant access crashes") def test01_variant_usage(self): """boost::variant usage""" diff --git a/test/test_concurrent.py b/test/test_concurrent.py index 7c176d0..6adea08 100644 --- a/test/test_concurrent.py +++ b/test/test_concurrent.py @@ -1,5 +1,5 @@ from pytest import mark, skip -from support import IS_LINUX_ARM, IS_MAC_ARM, IS_MAC_X86 +from support import IS_LINUX_ARM, IS_MAC_ARM class TestCONCURRENT: @@ -91,7 +91,6 @@ def test03_timeout(self): if t.is_alive(): # was timed-out cppjit.gbl.test12_timeout.stopit[0] = True - @mark.xfail(condition=IS_MAC_X86, reason="Fails on OS X x86") def test04_cpp_threading_with_exceptions(self): """Threads and Python exceptions""" @@ -173,7 +172,7 @@ def process(self, c): assert "RuntimeError" in w.err_msg assert "all wrong" in w.err_msg - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test05_float2d_callback(self): """Passing of 2-dim float arguments""" diff --git a/test/test_conversions.py b/test/test_conversions.py index 0e980f0..8741534 100644 --- a/test/test_conversions.py +++ b/test/test_conversions.py @@ -98,7 +98,7 @@ def test03_error_handling(self): assert CC.s_count == 0 @mark.xfail( - run=IS_CLANG_REPL, condition=IS_MAC or IS_CLING, reason="Crashes on Cling" + condition=IS_MAC or IS_CLING, run=IS_CLANG_REPL, reason="Crashes on Cling" ) def test04_implicit_conversion_from_tuple(self): """Allow implicit conversions from tuples as arguments {}-like""" diff --git a/test/test_cpp11features.py b/test/test_cpp11features.py index d5fc75f..a221480 100644 --- a/test/test_cpp11features.py +++ b/test/test_cpp11features.py @@ -26,7 +26,7 @@ def setup_class(cls): cls.cpp11features = cppjit.load_reflection_info(cls.test_dct) - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test01_smart_ptr(self): """Usage and access of std::shared/unique_ptr<>""" @@ -60,8 +60,8 @@ def test01_smart_ptr(self): assert TestSmartPtr.s_counter == 0 @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Valgrind issues on ARM", ) def test02_smart_ptr_construction(self): @@ -92,7 +92,7 @@ class C(TestSmartPtr): gc.collect() assert TestSmartPtr.s_counter == 0 - @mark.xfail(run=False, condition=IS_LINUX and IS_VALGRIND, reason="Valgrind issue") + @mark.xfail(condition=IS_LINUX and IS_VALGRIND, run=False, reason="Valgrind issue") def test03_smart_ptr_memory_handling(self): """Test shared/unique pointer memory ownership""" @@ -124,7 +124,7 @@ class C(TestSmartPtr): gc.collect() assert TestSmartPtr.s_counter == 0 - @mark.xfail(run=False, condition=IS_VALGRIND, reason="Crashes on Valgrind") + @mark.xfail(condition=IS_VALGRIND, run=False, reason="Crashes on Valgrind") def test04_shared_ptr_passing(self): """Ability to pass shared_ptr through shared_ptr""" @@ -444,7 +444,7 @@ def test13_stdhash(self): assert hash(sw) == 17 assert hash(sw) == 17 - @mark.xfail + @mark.xfail(reason="plain pointer does not convert to a shared_ptr argument") def test14_shared_ptr_passing(self): """Ability to pass normal pointers through shared_ptr by value""" @@ -498,7 +498,7 @@ def test15_unique_ptr_template_deduction(self): with raises(ValueError): # not an RValue cppjit.gbl.UniqueTempl.returnptr[int](uptr_in) - @mark.xfail(IS_MAC, reason="Fails on Mac platforms") + @mark.xfail(condition=IS_MAC, reason="Fails on Mac platforms") def test16_unique_ptr_moves(self): """std::unique_ptr requires moves""" @@ -590,8 +590,8 @@ def test18_unique_ptr_identity(self): assert p1 is p2 @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Valgrind issues on ARM", ) def test19_smartptr_from_callback(self): diff --git a/test/test_crossinheritance.py b/test/test_crossinheritance.py index ab0ae9e..7923749 100644 --- a/test/test_crossinheritance.py +++ b/test/test_crossinheritance.py @@ -52,7 +52,7 @@ def get_value(self): assert Base1.call_get_value(Base1()) == 42 assert Base1.call_get_value(Derived()) == 13 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test02_constructor(self): """Test constructor usage for derived classes""" @@ -90,7 +90,7 @@ def get_value(self): assert d.get_value() == 29 assert Base1.call_get_value(d) == 29 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test03_override_function_abstract_base(self): """Test ability to override a simple function with an abstract base""" @@ -149,8 +149,8 @@ def get_value(self): assert CX.IBase2.call_get_value(c4) == 77 @mark.xfail( - run=False, condition=IS_MAC_ARM, + run=False, reason="Crashes with exception not being caught on Apple Silicon", ) def test04_arguments(self): @@ -193,7 +193,7 @@ def pass_value5(self, b): d2 = Derived2() assert Base1.sum_pass_value(d2) == 12 + 4 * d2.m_int - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test05_override_overloads(self): """Test ability to override overloaded functions""" @@ -215,7 +215,7 @@ def sum_all(self, *args): assert d.sum_all(-7, -5) == 1 assert Base1.call_sum_all(d, -7, -5) == 1 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test06_const_methods(self): """Declared const methods should keep that qualifier""" @@ -239,9 +239,7 @@ def __init__(self): assert CX.IBase4.call_get_value(c1) == 17 assert CX.IBase4.call_get_value(c2) == 27 - @mark.xfail( - run=False, condition=IS_LINUX_ARM, reason="Fails with ModuleNotFound error" - ) + @mark.xfail(condition=IS_LINUX_ARM, reason="Fails with ModuleNotFoundError") def test07_templated_base(self): """Derive from a base class that is instantiated from a template""" @@ -264,7 +262,7 @@ def get_value(self): p1 = TPyDerived1() assert p1.get_value() == 13 - @mark.xfail(run=not IS_MAC_ARM, condition=IS_MAC, reason="Fails on OS X") + @mark.xfail(condition=IS_MAC_ARM, run=False, reason="Fails on macOS arm") def test08_error_handling(self): """Python errors should propagate through wrapper""" @@ -310,8 +308,8 @@ def sum_value(self, val): assert os.path.basename(__file__) in res @mark.xfail( - run=not IS_MAC_ARM, condition=IS_MAC_ARM, + run=False, reason="Crashes with exception not being caught on Apple Silicon", ) def test09_interface_checking(self): @@ -380,7 +378,7 @@ def call(self): gc.collect() assert CB.s_count == 0 + start_count - @mark.xfail(run=False, condition=IS_CLING, reason="Crashes on Cling") + @mark.xfail(condition=IS_CLING, run=False, reason="Crashes on Cling") def test11_python_in_make_shared(self): """Usage of Python derived objects with std::make_shared""" @@ -447,7 +445,7 @@ def call(self): gc.collect() assert CB.s_count == 0 + start_count - @mark.xfail(run=False, condition=IS_VALGRIND, reason="Valgrind issue") + @mark.xfail(condition=IS_VALGRIND, run=False, reason="Valgrind issue") def test12_python_shared_ptr_memory(self): """Usage of Python derived objects with std::shared_ptr""" @@ -564,7 +562,7 @@ def __init__(self): assert m.get_data() == 42 assert m.get_data_v() == 42 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test15_object_returns(self): """Return of C++ objects from overridden functions""" @@ -632,7 +630,6 @@ def whoami(self): assert not not new_obj assert new_obj.whoami() == "PyDerived4" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test16_cctor_access_controlled(self): """Python derived class of C++ class with access controlled cctor""" @@ -675,7 +672,6 @@ def whoami(self): obj = PyDerived() assert ns.callit(obj) == "PyDerived" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test17_deep_hierarchy(self): """Test a deep Python hierarchy with pure virtual functions""" @@ -722,7 +718,6 @@ def whoami(self): assert obj.whoami() == "PyDerived4" assert ns.callit(obj) == "PyDerived4" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test18_abstract_hierarchy(self): """Hierarchy with abstract classes""" @@ -799,7 +794,7 @@ class Derived(ns.Base): def abstract1(self): return ns.Result(1) - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test20_basic_multiple_inheritance(self): """Basic multiple inheritance""" @@ -879,8 +874,8 @@ def z(self): assert a.m_3 == 67 @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Crashes with Valgrind on Linux ARM", ) def test21_multiple_inheritance_with_constructors(self): @@ -971,8 +966,8 @@ def z(self): assert a.m_3 == -11 @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Crashes with Valgrind on Linux ARM", ) def test22_multiple_inheritance_with_defaults(self): @@ -1095,7 +1090,6 @@ def return_const(self): assert a.return_const().m_value == "abcdef" assert ns.callit(a).m_value == "abcdef" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test24_non_copyable(self): """Inheriting from a non-copyable base class""" @@ -1350,8 +1344,8 @@ class D(B): assert inst.fun2() == inst.fun1() @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Crashes with Valgrind on Linux ARM", ) def test29_cross_deep_multi(self): @@ -1603,8 +1597,8 @@ def getValue(self): assert ns.Component.get_count() == 0 @mark.xfail( - run=False, condition=IS_LINUX_ARM and IS_VALGRIND, + run=False, reason="Crashes with Valgrind on Linux ARM", ) def test32_by_value_arguments(self): @@ -1681,7 +1675,7 @@ def func(self): c = C() assert c.func() == 3 - @mark.xfail + @mark.xfail(reason="deriving from a ctor-less base does not raise TypeError") def test34_no_ctors_in_base(self): """Base classes with no constructors""" @@ -1800,7 +1794,6 @@ def __del__(self): del o1 assert Derived.was_py_deleted == True - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test37_deep_tree(self): """Find overridable methods deep in the tree""" @@ -1873,7 +1866,6 @@ def f3(self): assert pysub.f3() == "Python: PySub::f3()" assert ns.call_fs(pysub) == pysub.f1() + pysub.f2() + pysub.f3() - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test38_protected_data(self): """Multiple cross inheritance with protected data""" diff --git a/test/test_datatypes.py b/test/test_datatypes.py index 89df961..2983d4d 100644 --- a/test/test_datatypes.py +++ b/test/test_datatypes.py @@ -687,7 +687,6 @@ def test07_type_conversions(self): c.__destruct__() - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test08_global_builtin_type(self): """Test access to a global builtin type""" @@ -1409,7 +1408,7 @@ def run(self, f, buf, total): run(self, cppjit.gbl.sum_uc_data, buf, total) run(self, cppjit.gbl.sum_byte_data, buf, total) - @mark.xfail(run=False, condition=IS_MAC, reason="Crashes on OSX") + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes on OSX") def test26_function_pointers(self): """Function pointer passing""" @@ -1474,7 +1473,7 @@ def sum_in_python(i1, i2, i3): ns = cppjit.gbl.FuncPtrReturn assert ns.foo()() == "Hello, World!" - @mark.xfail(run=False, condition=IS_MAC, reason="Crashes") + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes") def test27_callable_passing(self): """Passing callables through function pointers""" @@ -1553,7 +1552,7 @@ def pyd(arg0, arg1): gc.collect() raises(TypeError, c, 3, 3) # lambda gone out of scope - @mark.xfail(run=False, condition=IS_MAC, reason="Crashes on MacOS") + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes on MacOS") def test28_callable_through_function_passing(self): """Passing callables through std::function""" @@ -1632,7 +1631,6 @@ def pyd(arg0, arg1): gc.collect() raises(TypeError, c, 3, 3) # lambda gone out of scope - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test29_std_function_life_lines(self): """Life lines to std::function data members""" @@ -1914,7 +1912,6 @@ def test34_object_pointers(self): assert c.s_strp == "noot" assert sn == "noot" # set through pointer - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test35_restrict(self): """Strip __restrict keyword from use""" diff --git a/test/test_doc_features.py b/test/test_doc_features.py index 70fa02e..fd15cdc 100644 --- a/test/test_doc_features.py +++ b/test/test_doc_features.py @@ -268,7 +268,7 @@ def test_enums(self): pass - @mark.xfail(run=False, condition=IS_MAC, reason="Seg Fault") + @mark.xfail(condition=IS_MAC, run=False, reason="Seg Fault") def test_functions(self): from cppjit.gbl import Namespace, call_int_int_function, global_function @@ -434,9 +434,6 @@ def abstract_method(self): pc = PyConcrete4() assert call_abstract_method(pc) == "Hello, Python World! (4)" - @mark.xfail( - condition=((IS_MAC) and IS_CLANG_REPL), reason="Fails on OSX with Clang-REPL" - ) def test_multi_x_inheritance(self): """Multiple cross-inheritance""" @@ -455,8 +452,8 @@ def abstract_method2(self): assert cppjit.gbl.call_abstract_method2(pc) == "second message" @mark.xfail( - run=False, condition=IS_MAC_ARM, + run=False, reason="Crashes with exception not being caught on Apple Silicon", ) def test_exceptions(self): @@ -583,9 +580,7 @@ def test02_python_introspection(self): assert isinstance(i, Integer1) @mark.xfail( - run=(not IS_MAC and IS_CLANG_REPL), - condition=IS_MAC and IS_CLING, - reason="Crashes on OS X Cling", + condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OS X Cling" ) def test03_STL_containers(self): """Instantiate STL containers with new class""" @@ -674,7 +669,6 @@ def test07_run_zoo(self): assert Zoo.identify_animal(mouse) == "the animal is a mouse" assert Zoo.identify_animal(lion) == "the animal is a lion" - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test08_shared_ptr(self): """Shared pointer transparency""" @@ -893,9 +887,7 @@ def test03_use_of_ctypes_and_enum(self): cppjit.gbl.free(vp) @mark.xfail( - run=(not IS_MAC and IS_CLANG_REPL), - condition=IS_MAC and IS_CLING, - reason="Crashes on OS X Cling", + condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OS X Cling" ) def test04_ptr_ptr_python_owns(self): """Example of ptr-ptr use where python owns""" @@ -1049,7 +1041,7 @@ def test08_voidptr_array(self): assert len(n.p) == 3 @mark.xfail( - condition=(IS_CLANG_REPL and IS_MAC), + condition=IS_CLANG_REPL and IS_MAC, run=False, reason="Crashes with ClangRepl with 'toString not implemented'", ) @@ -1167,7 +1159,7 @@ def test_template_instantiation(self): assert len(v) == 10 assert [m.fData for m in v] == list(range(10)) - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test_cross_inheritance(self): """Cross-inheritance example""" @@ -1187,7 +1179,7 @@ def add(self, i): m = PyMyClass(1) assert CC.callb(m, 2) == 5 - @mark.xfail(run=not IS_MAC_ARM, condition=IS_MAC_ARM, reason="Crashes on OS X arm") + @mark.xfail(condition=IS_MAC_ARM, run=False, reason="Crashes on OS X arm") def test_cross_and_templates(self): """Template instantiation with cross-inheritance example""" @@ -1207,7 +1199,7 @@ def add(self, i): assert v.back().add(17) == 4 + 42 + 2 * 17 - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test_fallbacks(self): """Template instantation switches based on value sizes""" @@ -1226,7 +1218,7 @@ def test_fallbacks(self): assert CC.passT(2**64 - 1) == 2**64 - 1 assert "unsigned long long" in CC.passT.__doc__ - @mark.xfail(run=False, condition=IS_LINUX_ARM, reason="Crashes pytest on Linux ARM") + @mark.xfail(condition=IS_LINUX_ARM, run=False, reason="Crashes pytest on Linux ARM") def test_callbacks(self): """Function callback example""" @@ -1254,8 +1246,8 @@ def f(val): assert CC.callFun(lambda i: 6 * i, 4) == 24 @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM, + run=False, reason="Crashes on Valgrind-ARM", ) def test_templated_callback(self): @@ -1328,7 +1320,6 @@ class MyException : public std::exception { with raises(CC.MyException): CC.throw_error() - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test_unicode(self): """Unicode non-UTF-8 example""" diff --git a/test/test_fragile.py b/test/test_fragile.py index e4cf3bc..631cc7a 100644 --- a/test/test_fragile.py +++ b/test/test_fragile.py @@ -21,6 +21,19 @@ def setup_module(mod): setup_make("fragile") +def has_asan_interface(): + import cppjit + + return ( + cppjit.evaluate("""#if __has_include() + true + #else + false + #endif\n""") + == 1 + ) + + class TestFRAGILE: def setup_class(cls): cls.test_dct = test_dct @@ -500,7 +513,6 @@ def test19_gbl_contents(self): assert "ESysConstants" not in dd assert "kDoRed" not in dd - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test20_capture_output(self): """Capture cerr into a string""" @@ -592,7 +604,10 @@ def test23_set_debug(self): cppjit.set_debug(False) assert cppjit.gbl.Cpp.IsDebugOutputEnabled() == False - @mark.xfail(condition=IS_LINUX, reason="Fails on Ubuntu") + @mark.xfail( + condition=IS_LINUX and not has_asan_interface(), + reason="sanitizer/asan_interface.h not available", + ) def test24_asan(self): """Check availability of ASAN with gcc""" @@ -603,7 +618,7 @@ def test24_asan(self): cppjit.include("sanitizer/asan_interface.h") - @mark.xfail + @mark.xfail(reason="cppdef of invalid code does not raise SyntaxError") def test25_cppdef_error_reporting(self): """Check error reporting of cppjit.cppdef""" diff --git a/test/test_lowlevel.py b/test/test_lowlevel.py index bcc7ac3..7a4be36 100644 --- a/test/test_lowlevel.py +++ b/test/test_lowlevel.py @@ -172,8 +172,8 @@ def test05_array_as_ref(self): assert f[0] == -5.0 @mark.xfail( - run=False, condition=IS_VALGRIND or IS_CLING, + run=False, reason="Valgrind detects memory leak with invalid delete[] operator, crashes on Cling", ) def test06_ctypes_as_ref_and_ptr(self): @@ -502,7 +502,7 @@ def test09_numpy_bool_array(self): x = np.array([True], dtype=bool) assert cppjit.gbl.convert_bool(x) - @mark.xfail(run=False, condition=IS_MAC, reason="Crashes on OSX") + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes on OSX") def test10_array_of_const_char_star(self): """Test passting of const char*[]""" diff --git a/test/test_numba.py b/test/test_numba.py index ee89390..081e4ae 100644 --- a/test/test_numba.py +++ b/test/test_numba.py @@ -491,7 +491,7 @@ def inc_c(d, k): assert c.value == y + k @mark.xfail( - run=False, condition=IS_LINUX_ARM, reason="Crash in llvmlite on Linux ARM" + condition=IS_LINUX_ARM, run=False, reason="Crash in llvmlite on Linux ARM" ) def test12_std_vector_pass_by_ref(self): """Numba-JITing of a method that performs scalar addition to a std::vector initialised through pointers""" diff --git a/test/test_overloads.py b/test/test_overloads.py index f736c8a..c9a8cd7 100644 --- a/test/test_overloads.py +++ b/test/test_overloads.py @@ -73,7 +73,6 @@ def test02_class_based_overloads_explicit_resolution(self): nb = ns_a_overload.b_overload() raises(TypeError, nb.f, c_overload()) - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test03_fragile_class_based_overloads(self): """Test functions overloaded on void* and non-existing classes""" @@ -95,7 +94,6 @@ def test03_fragile_class_based_overloads(self): dd = cppjit.gbl.get_dd_ol() assert more_overloads().call(dd) == "dd_ol" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test04_fully_fragile_overloads(self): """Test that unknown* is preferred over unknown&""" @@ -127,7 +125,6 @@ def test05_array_overloads(self): assert c_overload().get_int(ah) == 25 assert d_overload().get_int(ah) == 25 - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test06_double_int_overloads(self): """Test overloads on int/doubles""" @@ -156,7 +153,6 @@ def test07_mean_overloads(self): a = array.array(l, numbers) assert round(cmean(len(a), a) - mean, 8) == 0 - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test08_const_non_const_overloads(self): """Check selectability of const/non-const overloads""" @@ -215,7 +211,7 @@ def test09_bool_int_overloads(self): with raises(ValueError): cpp.BoolInt4.fff(2) - @mark.xfail(run=not IS_MAC_ARM, condition=IS_MAC, reason="Seg Faults") + @mark.xfail(condition=IS_MAC, run=not IS_MAC_ARM, reason="Seg Faults") def test10_overload_and_exceptions(self): """Prioritize reporting C++ exceptions from callee""" @@ -270,7 +266,6 @@ class MyClass3 { with raises(TypeError): ns.MyClass3("some_file") - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test11_deep_inheritance(self): """Prioritize expected most derived class""" diff --git a/test/test_pythonization.py b/test/test_pythonization.py index 61b0cee..f823546 100644 --- a/test/test_pythonization.py +++ b/test/test_pythonization.py @@ -165,8 +165,8 @@ def test04_transparency(self): assert mine.say_hi() == "Hi!" @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM and IS_CLANG_REPL, + run=False, reason="Crashes on Valgind Clang-Repl-ARM", ) def test05_converters(self): @@ -195,8 +195,8 @@ def test05_converters(self): pz.renew_mine() @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM and IS_CLANG_REPL, + run=False, reason="Fails with Valgrind with Clang-Repl ARM", ) def test06_executors(self): diff --git a/test/test_regression.py b/test/test_regression.py index 638fc50..af96a3b 100644 --- a/test/test_regression.py +++ b/test/test_regression.py @@ -30,7 +30,7 @@ def stringpager(text, title="", cls=cls): pydoc.pager = stringpager - @mark.xfail + @mark.xfail(reason="pydoc rendering of KDcrawIface fails") def test01_kdcraw(self): """Doc strings for KDcrawIface (used to crash).""" @@ -220,7 +220,7 @@ def test07_class_refcounting(self): assert sys.getrefcount(x) == old_refcnt - @mark.xfail(run=False, condition=IS_MAC and IS_CLING, reason="Crahes on OSX-Cling") + @mark.xfail(condition=IS_MAC and IS_CLING, run=False, reason="Crahes on OSX-Cling") def test08_typedef_identity(self): """Nested typedefs should retain identity""" @@ -262,7 +262,7 @@ def test09_gil_not_released(self): cppjit.cppdef(code) cppjit.gbl.some_foo_calling_python() - @mark.xfail(run=False, condition=IS_CLING, reason="Crashes on Cling") + @mark.xfail(condition=IS_CLING, run=False, reason="Crashes on Cling") def test10_enum_in_global_space(self): """Enum declared in search.h did not appear in global space""" @@ -383,7 +383,6 @@ class Bar { f = sds.Foo() assert f.bar.x == 5 - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test15_vector_vs_initializer_list(self): """Prefer vector in template and initializer_list in formal arguments""" @@ -556,7 +555,6 @@ class SignedCharRefGetter { assert obj.getter() == "c" - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test21_temporaries_and_vector(self): """Extend a life line to references into a vector if needed""" @@ -569,7 +567,6 @@ def test21_temporaries_and_vector(self): l = [e for e in cppjit.gbl.get_some_temporary_vector()] assert l == ["x", "y", "z"] - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test22_initializer_list_and_temporary(self): """Conversion rules when selecting intializer_list v.s. temporary""" @@ -824,8 +821,8 @@ def test28_exception_as_shared_ptr(self): assert not null @mark.xfail( - run=False, condition=(IS_CLING and IS_MAC) or IS_MAC_ARM, + run=False, reason="Dispatcher fix #53 introduces canonical types with std:: namespace that introduces OS X exceptions similar to test_stltypes", ) def test29_callback_pointer_values(self): @@ -1055,9 +1052,7 @@ def test34_print_empty_collection(self): v = cppjit.gbl.std.vector[int]() str(v) - @mark.xfail( - run=IS_CLANG_REPL, condition=IS_MAC or IS_CLING, reason="Crashes on Cling" - ) + @mark.xfail(condition=IS_CLING, run=False, reason="Crashes on Cling") def test35_filesytem(self): """Static path object used to crash on destruction""" @@ -1132,7 +1127,7 @@ def test37_array_of_pointers_argument(self): assert cppjit.addressof(res) == cppjit.addressof(arr) @mark.xfail( - run=False, condition=(IS_MAC and IS_CLING), reason="Crashes on OS X Cling" + condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OS X Cling" ) def test38_char16_arrays(self): """Access to fixed-size char16 arrays as data members""" @@ -1194,7 +1189,6 @@ def test38_char16_arrays(self): assert ai.name[:5] == "hello" cppjit.ll.array_delete(aa) - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test39_vector_of_pointers_conversion(self): """vector's const T*& used to be T**, now T*""" @@ -1270,7 +1264,7 @@ def test39_vector_of_pointers_conversion(self): assert type(list(vec2)[0]) == Base2 assert len([d for d in vec3 if isinstance(d, Derived3)]) == 1 - @mark.xfail(run=False, condition=not IS_CLANG_REPL, reason="Crashes with Cling") + @mark.xfail(condition=not IS_CLANG_REPL, run=False, reason="Crashes with Cling") def test40_explicit_initializer_list(self): """Construct and pass an explicit initializer list""" @@ -1439,8 +1433,8 @@ def test45_typedef_resolution(self): assert cppjit.gbl.cppjit.interop.ResolveName("cmy_custom_type_t") == "const int" @mark.xfail( - run=False, condition=IS_MAC_ARM, + run=False, reason="Crashes with exception not being caught on Apple Silicon", ) def test46_exception_narrowing(self): diff --git a/test/test_stltypes.py b/test/test_stltypes.py index 4873977..40795b0 100644 --- a/test/test_stltypes.py +++ b/test/test_stltypes.py @@ -313,7 +313,7 @@ def test01_builtin_type_vector_types(self): assert v.size() == self.N assert len(v) == self.N - @mark.xfail(condition=IS_MAC, run=not IS_MAC, reason="Crashes on OSX") + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes on OSX") def test02_user_type_vector_type(self): """Test access to an std::vector""" @@ -450,9 +450,7 @@ def test06_vector_indexing(self): assert v2[-1] == v[-2] assert v2[self.N - 4] == v[-2] - @mark.xfail( - run=False, condition=(IS_MAC and IS_CLING), reason="Crashes on OSX Cling" - ) + @mark.xfail(condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OSX Cling") def test07_vector_bool(self): """Usability of std::vector which can be a specialization""" @@ -471,7 +469,7 @@ def test07_vector_bool(self): assert len(vb[4:8]) == 4 assert list(vb[4:8]) == [False] * 3 + [True] - @mark.xfail(run=False, condition=IS_MAC and IS_CLING, reason="Crashes on OSX-Cling") + @mark.xfail(condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OSX-Cling") def test08_vector_enum(self): """Usability of std::vector<> of some enums""" @@ -493,9 +491,7 @@ def test08_vector_enum(self): ve[0] = cppjit.gbl.VecTestEnumNS.EVal2 assert ve[0] == 42 - @mark.xfail( - run=not (IS_MAC_ARM or IS_MAC_X86), condition=IS_MAC, reason="Fails on OS X" - ) + @mark.xfail(condition=IS_MAC, run=False, reason="Fails on OS X") def test09_vector_of_string(self): """Adverse effect of implicit conversion on vector""" @@ -596,8 +592,8 @@ def test12_vector_lifeline(self): assert hasattr(val, "__lifeline") @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM and IS_CLANG_REPL, + run=False, reason="Fails with Valgrind with Clang-Repl ARM", ) def test13_vector_smartptr_iteration(self): @@ -633,11 +629,7 @@ def test13_vector_smartptr_iteration(self): i += 1 assert i == len(result) - @mark.xfail( - run=not (IS_MAC and IS_CLING), - condition=(IS_MAC and IS_CLING), - reason="Fails on OSX-Cling", - ) + @mark.xfail(condition=IS_MAC and IS_CLING, run=False, reason="Fails on OSX-Cling") def test14_vector_of_vector_of_(self): """Nested vectors""" @@ -776,7 +768,6 @@ class Point3D { assert cppsum == pysum - @mark.xfail(condition=IS_CLING, reason="Fails on Cling") def test20_vector_cstring(self): """Usage of a vector of const char*""" @@ -993,7 +984,6 @@ def test03_string_with_null_character(self): assert repr(std.string("ab\0c")) == repr(b"ab\0c") assert str(std.string("ab\0c")) == str("ab\0c") - @mark.xfail(condition=IS_MAC, run=False, reason="Fails on OS X") def test04_array_of_strings(self): """Access to global arrays of strings""" @@ -1074,9 +1064,7 @@ def test05_stlstring_and_unicode(self): assert str(uas.get_string_cr(bval)) == "ℕ" assert str(uas.get_string_cc(bval)) == "ℕ" - @mark.xfail( - run=not IS_CLING, condition=IS_MAC or IS_CLING, reason="Fails on OS X and Cling" - ) + @mark.xfail(condition=IS_CLING, run=False, reason="Fails on Cling") def test06_stlstring_bytes_and_text(self): """Mixing of bytes and str""" @@ -1326,7 +1314,7 @@ def test04_iter_of_iter(self): assert a == i i += 1 - @mark.xfail(run=False, condition=IS_MAC and IS_CLING, reason="Crashes on OSX-Cling") + @mark.xfail(condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OSX-Cling") def test05_list_cpp17_style(self): """C++17 style initialization of std::list""" @@ -1894,11 +1882,7 @@ def test02_string_view_from_unicode(self): assert "Lorem ipsum dolor sit amet" in str(text) - @mark.xfail( - run=not IS_MAC, - condition=IS_MAC or IS_CLING, - reason="Crashes on OSX, fails with cling", - ) + @mark.xfail(condition=IS_MAC, run=False, reason="Crashes on OSX") def test03_string_view_pythonize(self): """Pythonization of std::string_view""" @@ -1944,7 +1928,7 @@ def test01_deque_byvalue_regression(self): del x @mark.xfail( - run=False, condition=IS_MAC and IS_CLING, reason="Crashes on OS X Cling" + condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OS X Cling" ) def test02_deque_cpp17_style(self): """C++17 style initialization of std::deque""" @@ -2024,7 +2008,7 @@ def test03_initialize_from_set(self): s = cppjit.gbl.std.set[int](set(["aap", "noot", "mies"])) @mark.xfail( - run=False, condition=IS_MAC and IS_CLING, reason="Crashes with OSX-Cling" + condition=IS_MAC and IS_CLING, run=False, reason="Crashes with OSX-Cling" ) def test04_set_cpp17_style(self): """C++17 style initialization of std::set""" @@ -2259,7 +2243,7 @@ def raiseit(cls): except cppjit.gbl.YourError as e: assert e.what() == "Oops" - @mark.xfail(condition=(IS_MAC_ARM or IS_MAC_X86), reason="Fails with OS X") + @mark.xfail(condition=IS_MAC_ARM or IS_MAC_X86, reason="Fails with OS X") def test03_memory(self): """Memory handling of C++ c// helper for exception base class testing""" @@ -2308,7 +2292,7 @@ def run_raiseit(t1, t2): gc.collect() assert cppjit.gbl.GetMyErrorCount() == 0 - @mark.xfail(run=False, condition=IS_MAC_ARM, reason="Seg Faults on OSX-ARM") + @mark.xfail(condition=IS_MAC_ARM, run=False, reason="Seg Faults on OSX-ARM") def test04_from_cpp(self): """Catch C++ exceptiosn from C++""" @@ -2354,6 +2338,11 @@ def has_cpp_20(): class TestSTLSPAN: import cppjit + def setup_class(cls): + import cppjit + + cppjit.include("span") + def test01_span_iterators(self): """ Test that std::span::begin() and std::span::end() can be used. diff --git a/test/test_streams.py b/test/test_streams.py index 6fc6052..8045382 100644 --- a/test/test_streams.py +++ b/test/test_streams.py @@ -1,6 +1,5 @@ import py -from pytest import mark -from support import IS_MAC, setup_make +from support import setup_make currpath = py.path.local(__file__).dirpath() test_dct = str(currpath.join("cpp/std_streamsDict")) @@ -34,7 +33,6 @@ def test02_std_cout(self): assert cppjit.gbl.std.cout is not None - @mark.xfail(condition=IS_MAC, reason="Fails on OS X") def test03_consistent_naming_if_char_traits(self): """Naming consistency if char_traits""" diff --git a/test/test_templates.py b/test/test_templates.py index 7f2ad13..127ec7f 100644 --- a/test/test_templates.py +++ b/test/test_templates.py @@ -295,7 +295,7 @@ class RTTest_SomeClassWithTCtor { assert round(RTTest2[int](1, 3.1).m_double - 4.1, 8) == 0.0 assert round(RTTest2[int]().m_double + 1.0, 8) == 0.0 - @mark.xfail(run=False, condition=IS_CLING, reason="Crashes on Cling") + @mark.xfail(condition=IS_CLING, run=False, reason="Crashes on Cling") def test12_template_aliases(self): """Access to templates made available with 'using'""" @@ -472,7 +472,6 @@ def get_tn(ns): b.b_T["int"](1, 1.0, "a") assert get_tn(ns).find("int(some_variadic::B::*)(int&&,double&&,std::") == 0 - @mark.xfail(condition=IS_MAC, reason="Fails on OSX") def test17_empty_body(self): """Use of templated function with empty body""" @@ -617,8 +616,8 @@ def test23_overloaded_setitem(self): v[0] = 1 # used to throw TypeError @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM and IS_CLING, + run=False, reason="Crashes on Valgind Cling-ARM", ) def test24_stdfunction_templated_arguments(self): @@ -648,8 +647,8 @@ def callback(x): assert cppjit.gbl.std.function["double(std::vector)"] @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM, + run=False, reason="Crashes on Valgrind-ARM", ) def test25_stdfunction_ref_and_ptr_args(self): @@ -838,8 +837,8 @@ def test28_enum_in_constructor(self): assert ns.FS("i", ns.ST.TI.I32, ns.FS.R.EQ, 10) @mark.xfail( - run=False, condition=IS_VALGRIND and IS_LINUX_ARM, + run=False, reason="Crashes on Valgrind-ARM", ) def test29_function_ptr_as_template_arg(self): @@ -952,7 +951,7 @@ class Templated: public NonTemplated { ns.Templated() # used to crash - @mark.xfail(run=False, condition=IS_CLING, reason="Crashed with Cling") + @mark.xfail(condition=IS_CLING, run=False, reason="Crashed with Cling") def test31_ltlt_in_template_name(self): """Verify lookup of template names with << in the name""" @@ -1198,7 +1197,7 @@ class TNaVU; getattr(run_n, t) @mark.xfail( - run=False, condition=IS_MAC and IS_CLING, reason="Crashes on OS X + Cling" + condition=IS_MAC and IS_CLING, run=False, reason="Crashes on OS X + Cling" ) def test33_using_template_argument(self): """`using` type as template argument""" @@ -1459,7 +1458,7 @@ def setup_class(cls): cls.templates = cppjit.load_reflection_info(cls.test_dct) - @mark.xfail + @mark.xfail(reason="using-typedef resolution drops non-type template args") def test01_using(self): """Test presence and validity of using typedefs""" From d1f5c8e8cdecc1be2522b87e8c2d01af75f2ebda Mon Sep 17 00:00:00 2001 From: Aaron Jomy <75925957+aaronj0@users.noreply.github.com> Date: Tue, 1 Sep 2026 14:42:44 +0200 Subject: [PATCH 12/17] [ci] Harden the wheels workflow and cibuildwheel config (#59) --- .github/wheel_contents_check.py | 32 +++++++++++++++ .github/workflows/wheels.yml | 69 +++++++++++++++++++++++++++++++++ pyproject.toml | 12 ++++-- zizmor.yml | 9 +++++ 4 files changed, 119 insertions(+), 3 deletions(-) create mode 100644 .github/wheel_contents_check.py create mode 100644 zizmor.yml diff --git a/.github/wheel_contents_check.py b/.github/wheel_contents_check.py new file mode 100644 index 0000000..fb39f0c --- /dev/null +++ b/.github/wheel_contents_check.py @@ -0,0 +1,32 @@ +"""Fail when a wheel holds a file outside the install-layout allowlist. + +Usage: python wheel_contents_check.py [ ...]""" + +import fnmatch +import sys +import zipfile + +# fnmatch's * crosses path separators, so one pattern covers a subtree. +ALLOWED = [ + "cppjit/*.py", + "cppjit/libcppjit.so", + "cppjit/interop/lib/libclangCppInterOp*", + "cppjit/interop/lib/clang/*", + "cppjit/interop/include/*", + "cppjit-*.dist-info/*", +] + + +def check(path): + # directory entries (trailing slash) carry no content + members = [m for m in zipfile.ZipFile(path).namelist() if not m.endswith("/")] + bad = [m for m in members if not any(fnmatch.fnmatch(m, p) for p in ALLOWED)] + for member in bad: + print(f"{path}: unexpected member {member}") + return not bad + + +if __name__ == "__main__": + if len(sys.argv) < 2: + sys.exit(__doc__) + sys.exit(0 if all([check(path) for path in sys.argv[1:]]) else 1) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index a7b3cb4..0ea475c 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -11,6 +11,7 @@ on: paths: - '.github/workflows/wheels.yml' - '.github/wheel_smoke.py' + - '.github/wheel_contents_check.py' - 'pyproject.toml' - 'CMakeLists.txt' - 'cmake/**' @@ -41,6 +42,8 @@ jobs: steps: - uses: actions/checkout@v7 + with: + persist-credentials: false # ref pins the recipe content the cache key is computed from. - uses: compiler-research/ci-workflows/actions/setup-recipe@main @@ -59,23 +62,36 @@ jobs: - uses: pypa/cibuildwheel@v4.2.0 + - name: Assert the build left the checkout clean + run: git diff --exit-code + + - name: Check the wheels against the content allowlist + run: python3 .github/wheel_contents_check.py wheelhouse/*.whl + - uses: actions/upload-artifact@v7 with: name: wheels-${{ matrix.label }} path: wheelhouse/*.whl + if-no-files-found: error sdist: name: sdist runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v7 + with: + persist-credentials: false - run: pipx run build --sdist + - name: Check the sdist metadata + run: pipx run twine check dist/*.tar.gz + - uses: actions/upload-artifact@v7 with: name: sdist path: dist/*.tar.gz + if-no-files-found: error # Run the full suite on a plain runner, outside the manylinux # container the wheel was built in. @@ -85,6 +101,8 @@ jobs: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v7 + with: + persist-credentials: false - uses: actions/setup-python@v7 with: @@ -112,3 +130,54 @@ jobs: cd test make -j$(nproc) PYTHON=python python -m pytest -ra + + # Build from the sdist and run the full suite against the install. + test-sdist: + name: test sdist (build + full suite) + needs: sdist + runs-on: ubuntu-24.04 + steps: + - uses: actions/checkout@v7 + with: + persist-credentials: false + + - uses: actions/setup-python@v7 + with: + python-version: '3.12' + + - uses: compiler-research/ci-workflows/actions/setup-recipe@main + id: llvm + with: + recipe: llvm-wheel + version: '21.1.8' + os: ubuntu-24.04 + arch: x86_64 + ref: b760e4c171961786b7b20e2cc514302df5373eef + + - uses: actions/download-artifact@v8 + with: + name: sdist + path: dist + + - name: Install the test suite's native deps + run: sudo apt-get -q update && sudo apt-get -y install libeigen3-dev libboost-dev + + - name: Build and install from the sdist with the test requirements + env: + RECIPE_PATH: ${{ steps.llvm.outputs.path }} + run: > + python -m pip install dist/cppjit-*.tar.gz -v + --config-settings=cmake.define.LLVM_DIR="$RECIPE_PATH/lib/cmake/llvm" + --config-settings=cmake.define.Clang_DIR="$RECIPE_PATH/lib/cmake/clang" + -r requirements.txt + + - name: Smoke the install outside pytest + run: python -X faulthandler .github/wheel_smoke.py + + - name: Run the test suite against the sdist install + env: + CPPINTEROP_EXTRA_INTERPRETER_ARGS: -std=c++20 + run: | + cd test + make -j$(nproc) PYTHON=python + python -m pytest -ra diff --git a/pyproject.toml b/pyproject.toml index b9a2821..521cde6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,6 +25,7 @@ minimum-version = "build-system.requires" wheel.install-dir = "." wheel.packages = ["python/cppjit"] cmake.build-type = "Release" +sdist.exclude = [".github", ".gitignore", ".clang-format"] [[tool.dynamic-metadata]] provider = "scikit_build_core.metadata.regex" @@ -32,23 +33,28 @@ field = "version" input = "python/cppjit/_version.py" [tool.cibuildwheel] +# cp314t needs a free-threading audit first; cp315 joins at its release. build = ["cp312-*", "cp313-*", "cp314-*"] skip = ["*-musllinux*"] build-verbosity = 1 +audit-requires = ["twine"] +audit-command = "twine check {wheel}" test-sources = ["test", "requirements.txt", ".github/wheel_smoke.py"] test-command = "python .github/wheel_smoke.py" +# imports must resolve from the installed wheel, not the checkout +test-environment = { PYTHONSAFEPATH = "1" } [tool.cibuildwheel.linux] archs = ["x86_64"] manylinux-x86_64-image = "manylinux_2_28" # /opt/llvm is staged on the runner by wheels.yml. -container-engine = { name = "docker", create-args = ["--volume=/opt/llvm:/opt/llvm"] } +container-engine = { name = "docker", create-args = ["--volume=/opt/llvm:/opt/llvm"], disable-host-mount = true } environment = { CMAKE_ARGS = "-DLLVM_DIR=/opt/llvm/lib/cmake/llvm -DClang_DIR=/opt/llvm/lib/cmake/clang" } [tool.cibuildwheel.macos] archs = ["arm64"] -before-test = "brew install eigen boost" -test-command = "python -m pip install -r requirements.txt && python .github/wheel_smoke.py && cd test && make -j$(sysctl -n hw.ncpu) PYTHON=python && CPPINTEROP_EXTRA_INTERPRETER_ARGS=-std=c++20 python -m pytest -ra" +before-test = "brew install eigen boost && python -m pip install -r {project}/requirements.txt" +test-command = "python .github/wheel_smoke.py && cd test && make -j$(sysctl -n hw.ncpu) PYTHON=python && CPPINTEROP_EXTRA_INTERPRETER_ARGS=-std=c++20 python -m pytest -ra" environment = { CMAKE_ARGS = "-DLLVM_DIR=/opt/llvm/lib/cmake/llvm -DClang_DIR=/opt/llvm/lib/cmake/clang", MACOSX_DEPLOYMENT_TARGET = "14.0" } [tool.pytest.ini_options] diff --git a/zizmor.yml b/zizmor.yml new file mode 100644 index 0000000..7bb1574 --- /dev/null +++ b/zizmor.yml @@ -0,0 +1,9 @@ +# Version tags for the actions we consume; compiler-research/* rides @main. +rules: + unpinned-uses: + config: + policies: + "actions/*": ref-pin + "pypa/*": ref-pin + "compiler-research/*": ref-pin + "*": hash-pin From c69e8c5d2d6f3c0116465c4d5bda52f4dc4e53ca Mon Sep 17 00:00:00 2001 From: mcbarton Date: Thu, 27 Aug 2026 14:48:23 +0100 Subject: [PATCH 13/17] Remove obsolete single_module flag --- test/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Makefile b/test/Makefile index 7f1433e..62d1d22 100644 --- a/test/Makefile +++ b/test/Makefile @@ -26,7 +26,7 @@ cppflags= -std=c++17 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; p PLATFORM := $(shell uname -s) ifeq ($(PLATFORM),Darwin) - cppflags+=-dynamiclib -single_module -undefined dynamic_lookup -Wno-delete-non-virtual-dtor + cppflags+=-dynamiclib -undefined dynamic_lookup -Wno-delete-non-virtual-dtor endif # a worker can load the library while another rebuilds it, so publish it whole From 55c879eb38a18723fb98349a0eafd7a2bd6b9665 Mon Sep 17 00:00:00 2001 From: mcbarton Date: Thu, 27 Aug 2026 16:39:45 +0100 Subject: [PATCH 14/17] Update warning flags and update test standard to C++20 --- CMakeLists.txt | 2 +- test/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 465d158..7722c04 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -142,7 +142,7 @@ target_include_directories(cppjit PRIVATE ) target_compile_options(cppjit PRIVATE - -Wall -Wno-strict-aliasing -Wno-register + -Wall -Wextra -Wno-strict-aliasing -Wno-register -Werror ) if(CMAKE_COMPILER_IS_GNUCXX) diff --git a/test/Makefile b/test/Makefile index 62d1d22..0cd3372 100644 --- a/test/Makefile +++ b/test/Makefile @@ -22,7 +22,7 @@ dicts = $(addprefix cpp/,$(addsuffix Dict.so,$(dictnames))) all : $(dicts) PYTHON ?= python3 -cppflags= -std=c++17 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register +cppflags= -Wall -Wextra -Werror -std=c++20 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register PLATFORM := $(shell uname -s) ifeq ($(PLATFORM),Darwin) From fe4135f36449fd5fc3cad957c1d8d23d6fefec7c Mon Sep 17 00:00:00 2001 From: mcbarton Date: Thu, 27 Aug 2026 18:23:24 +0100 Subject: [PATCH 15/17] Try new fix Try to fix more warnings Try to fix more warnings Try to fix error Try fixes Revert "Try fixes" This reverts commit 1adc6fbca31032d32399498846c1f7452b84842a. Try partial fix Try fix Attempt partial fix Attempt partial fix Try partial fix Try fix Try fix Attempt fix Fix Test fix Test fix Test Test fix Revert "Test fix" This reverts commit e4eff56e553d3b7d8355b535d6b3d7404df3598d. Test fix Test fix Test fix Test fix Test fix Test fix Try fix Test fix Try fix Partial fix Revert "Partial fix" This reverts commit 1bee1a84b0e6b016724f00cf9dc8240acc8461ed. Revert test makefile changes Try fixing test Try to fix Revert "Try fixing test" This reverts commit 09db7cd4cd79ce04938d723f45eff9d3dcdc206b. Revert "Try fix" This reverts commit f0f32c1cbc95294251d385cb4c85cac3b47fa07c. Revert "Test fix" This reverts commit 88a03b155a06a95de7ae03685bcb36dc302676b7. Revert "Try fix" This reverts commit e32f2927c293cc4528de66d1e9ad8e79f075a19a. --- src/cpyrt/CPPEnum.cxx | 6 +- src/cpyrt/CPPInstance.cxx | 33 +++--- src/cpyrt/CPPOverload.cxx | 52 ++++++---- src/cpyrt/CPPScope.cxx | 5 +- src/cpyrt/LowLevelViews.cxx | 106 ++++++++++---------- src/cpyrt/MemoryRegulator.cxx | 7 +- src/cpyrt/Pythonize.cxx | 184 +++++++++++++++++++--------------- src/cpyrt/cpyrtModule.cxx | 8 +- test/Makefile | 2 +- 9 files changed, 220 insertions(+), 183 deletions(-) diff --git a/src/cpyrt/CPPEnum.cxx b/src/cpyrt/CPPEnum.cxx index 6585265..f64dad8 100644 --- a/src/cpyrt/CPPEnum.cxx +++ b/src/cpyrt/CPPEnum.cxx @@ -139,7 +139,7 @@ static PyTypeObject* GetCTypesType(const std::string& cppname) { return (PyTypeObject*)PyObject_GetAttrString(ctmod, nn->second.c_str()); } -static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds) { +static PyObject* enum_ctype(PyObject* cls, PyObject* args) { PyObject* pyres = PyObject_GetAttr(cls, cpyrt::PyStrings::gUnderlying); if (!pyres) PyErr_Clear(); @@ -149,7 +149,7 @@ static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds) { if (!ct) return nullptr; - return PyType_Type.tp_call((PyObject*)ct, args, kwds); + return PyType_Type.tp_call((PyObject*)ct, args, nullptr); } //- creation ----------------------------------------------------------------- @@ -213,7 +213,7 @@ cpyrt::CPPEnum* cpyrt::CPPEnum_New(const std::string& name, // add pythonizations Utility::AddToClass((PyObject*)Py_TYPE(pyenum), "__ctype__", - (PyCFunction)enum_ctype, METH_VARARGS | METH_KEYWORDS); + enum_ctype, METH_VARARGS); ((PyTypeObject*)pyenum)->tp_repr = enum_repr; ((PyTypeObject*)pyenum)->tp_str = ((PyTypeObject*)pyside_type)->tp_repr; diff --git a/src/cpyrt/CPPInstance.cxx b/src/cpyrt/CPPInstance.cxx index 59cde8a..9d9c9d7 100644 --- a/src/cpyrt/CPPInstance.cxx +++ b/src/cpyrt/CPPInstance.cxx @@ -270,18 +270,17 @@ static int op_nonzero(CPPInstance* self) { } //= cpyrt object explicit destruction ===================================== -static PyObject* op_destruct(CPPInstance* self) { +static PyObject* op_destruct(PyObject* self, PyObject* /*args*/) { // User access to force deletion of the object. Needed in case of a true // garbage collector (like in PyPy), to allow the user control over when // the C++ destructor is called. This method requires that the C++ object // is owned (no-op otherwise). - op_dealloc_nofree(self); + op_dealloc_nofree((CPPInstance*)self); Py_RETURN_NONE; } //= cpyrt object dispatch support ========================================= -static PyObject* op_dispatch(PyObject* self, PyObject* args, - PyObject* /* kdws */) { +static PyObject* op_dispatch(PyObject* self, PyObject* args) { // User-side __dispatch__ method to allow selection of a specific overloaded // method. The actual selection is in the __overload__() method of // CPPOverload. @@ -312,13 +311,14 @@ static PyObject* op_dispatch(PyObject* self, PyObject* args, } //= cpyrt smart pointer support =========================================== -static PyObject* op_get_smartptr(CPPInstance* self) { - if (!self->IsSmart()) { +static PyObject* op_get_smartptr(PyObject* self, PyObject* /*args*/) { + CPPInstance* inst = (CPPInstance*)self; + if (!inst->IsSmart()) { // TODO: more likely should raise Py_RETURN_NONE; } - return cpyrt::BindCppObjectNoCast(self->GetSmartObject(), SMART_TYPE(self), + return cpyrt::BindCppObjectNoCast(inst->GetSmartObject(), SMART_TYPE(inst), CPPInstance::kNoWrapConv); } @@ -335,7 +335,8 @@ Py_ssize_t cpyrt::CPPInstance::ArrayLength() { return (Py_ssize_t)ARRAY_SIZE(this); } -static PyObject* op_reshape(CPPInstance* self, PyObject* shape) { +static PyObject* op_reshape(PyObject* self, PyObject* shape) { + CPPInstance* inst = (CPPInstance*)self; // Allow the user to fix up the actual (type-strided) size of the buffer. if (!PyTuple_Check(shape) || PyTuple_GET_SIZE(shape) != 1) { PyErr_SetString(PyExc_TypeError, "tuple object of size 1 expected"); @@ -348,7 +349,7 @@ static PyObject* op_reshape(CPPInstance* self, PyObject* shape) { return nullptr; } - self->CastToArray(sz); + inst->CastToArray(sz); Py_RETURN_NONE; } @@ -417,26 +418,26 @@ PyCFunction& CPPInstance::ReduceMethod() { return reducer; } -PyObject* op_reduce(PyObject* self, PyObject* args) { +PyObject* op_reduce(PyObject* self, PyObject* /*args*/) { auto& reducer = CPPInstance::ReduceMethod(); if (!reducer) { PyErr_SetString(PyExc_NotImplementedError, ""); return nullptr; } - return reducer(self, args); + return reducer(self, nullptr); } //---------------------------------------------------------------------------- static PyMethodDef op_methods[] = { - {(char*)"__destruct__", (PyCFunction)op_destruct, METH_NOARGS, + {(char*)"__destruct__", op_destruct, METH_NOARGS, (char*)"call the C++ destructor"}, - {(char*)"__dispatch__", (PyCFunction)op_dispatch, METH_VARARGS, + {(char*)"__dispatch__", op_dispatch, METH_VARARGS, (char*)"dispatch to selected overload"}, - {(char*)"__smartptr__", (PyCFunction)op_get_smartptr, METH_NOARGS, + {(char*)"__smartptr__", op_get_smartptr, METH_NOARGS, (char*)"get associated smart pointer, if any"}, - {(char*)"__reduce__", (PyCFunction)op_reduce, METH_NOARGS, + {(char*)"__reduce__", op_reduce, METH_NOARGS, (char*)"reduce method for serialization"}, - {(char*)"__reshape__", (PyCFunction)op_reshape, METH_O, + {(char*)"__reshape__", op_reshape, METH_O, (char*)"cast pointer to 1D array type"}, {(char*)nullptr, nullptr, 0, nullptr}}; diff --git a/src/cpyrt/CPPOverload.cxx b/src/cpyrt/CPPOverload.cxx index 49778df..cbe1053 100644 --- a/src/cpyrt/CPPOverload.cxx +++ b/src/cpyrt/CPPOverload.cxx @@ -218,18 +218,20 @@ static inline PyObject* HandleReturn(CPPOverload* pymeth, CPPInstance* im_self, } //= cpyrt method proxy object behaviour =================================== -static PyObject* mp_name(CPPOverload* pymeth, void*) { +static PyObject* mp_name(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; return cpyrt_PyText_FromString(pymeth->GetName().c_str()); } //---------------------------------------------------------------------------- -static PyObject* mp_module(CPPOverload* /* pymeth */, void*) { +static PyObject* mp_module(PyObject*, void*) { Py_INCREF(PyStrings::gThisModule); return PyStrings::gThisModule; } //---------------------------------------------------------------------------- -static PyObject* mp_doc(CPPOverload* pymeth, void*) { +static PyObject* mp_doc(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; if (pymeth->fMethodInfo->fDoc) { Py_INCREF(pymeth->fMethodInfo->fDoc); return pymeth->fMethodInfo->fDoc; @@ -259,7 +261,8 @@ static PyObject* mp_doc(CPPOverload* pymeth, void*) { return doc; } -static int mp_doc_set(CPPOverload* pymeth, PyObject* val, void*) { +static int mp_doc_set(PyObject* self, PyObject* val, void*) { + CPPOverload* pymeth = (CPPOverload*)self; Py_XDECREF(pymeth->fMethodInfo->fDoc); Py_INCREF(val); pymeth->fMethodInfo->fDoc = val; @@ -276,8 +279,8 @@ static int mp_doc_set(CPPOverload* pymeth, PyObject* val, void*) { * 'int ::foo(int a)': ('a',), * 'int ::foo(int a, float b)': ('a', 'b')} */ -static PyObject* mp_func_overloads_names(CPPOverload* pymeth) { - +static PyObject* mp_func_overloads_names(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; const CPPOverload::Methods_t& methods = pymeth->fMethodInfo->fMethods; PyObject* overloads_names_dict = PyDict_New(); @@ -301,8 +304,8 @@ static PyObject* mp_func_overloads_names(CPPOverload* pymeth) { * ('int',), 'return_type': 'int'}, 'int ::foo(int a, float b)': {'input_types': * ('int', 'float'), 'return_type': 'int'}} */ -static PyObject* mp_func_overloads_types(CPPOverload* pymeth) { - +static PyObject* mp_func_overloads_types(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; const CPPOverload::Methods_t& methods = pymeth->fMethodInfo->fMethods; PyObject* overloads_types_dict = PyDict_New(); @@ -316,7 +319,8 @@ static PyObject* mp_func_overloads_types(CPPOverload* pymeth) { } //---------------------------------------------------------------------------- -static PyObject* mp_meth_func(CPPOverload* pymeth, void*) { +static PyObject* mp_meth_func(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Create a new method proxy to be returned. CPPOverload* newPyMeth = (CPPOverload*)CPPOverload_Type.tp_alloc(&CPPOverload_Type, 0); @@ -333,7 +337,8 @@ static PyObject* mp_meth_func(CPPOverload* pymeth, void*) { } //---------------------------------------------------------------------------- -static PyObject* mp_meth_self(CPPOverload* pymeth, void*) { +static PyObject* mp_meth_self(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Return the bound self, if any; in case of pseudo-function role, pretend // that the data member im_self does not exist. if (IsPseudoFunc(pymeth)) { @@ -350,7 +355,8 @@ static PyObject* mp_meth_self(CPPOverload* pymeth, void*) { } //---------------------------------------------------------------------------- -static PyObject* mp_meth_class(CPPOverload* pymeth, void*) { +static PyObject* mp_meth_class(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Return scoping class; in case of pseudo-function role, pretend that there // is no encompassing class (i.e. global scope). if (!IsPseudoFunc(pymeth) && pymeth->fMethodInfo->fMethods.size()) { @@ -366,13 +372,13 @@ static PyObject* mp_meth_class(CPPOverload* pymeth, void*) { } //---------------------------------------------------------------------------- -static PyObject* mp_func_closure(CPPOverload* /* pymeth */, void*) { +static PyObject* mp_func_closure(PyObject*, void*) { // Stub only, to fill out the python function interface. Py_RETURN_NONE; } //---------------------------------------------------------------------------- -static PyObject* mp_func_code(CPPOverload*, void*) { +static PyObject* mp_func_code(PyObject*, void*) { // Code details are used in module inspect to fill out interactive help() // not important for functioning of most code, so not implemented for p3 for // now (TODO) @@ -380,7 +386,8 @@ static PyObject* mp_func_code(CPPOverload*, void*) { } //---------------------------------------------------------------------------- -static PyObject* mp_func_defaults(CPPOverload* pymeth, void*) { +static PyObject* mp_func_defaults(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Create a tuple of default values, if there is only one method (otherwise // leave undefined: this is only used by inspect for interactive help()) CPPOverload::Methods_t& methods = pymeth->fMethodInfo->fMethods; @@ -406,7 +413,7 @@ static PyObject* mp_func_defaults(CPPOverload* pymeth, void*) { } //---------------------------------------------------------------------------- -static PyObject* mp_func_globals(CPPOverload* /* pymeth */, void*) { +static PyObject* mp_func_globals(PyObject*, void*) { // Return this function's global dict (hard-wired to be the cppjit module); // used for lookup of names from co_code indexing into co_names. PyObject* pyglobal = PyModule_GetDict(PyImport_AddModule((char*)"cppjit")); @@ -438,19 +445,22 @@ static inline int set_flag(CPPOverload* pymeth, PyObject* value, } //---------------------------------------------------------------------------- -static PyObject* mp_getcreates(CPPOverload* pymeth, void*) { +static PyObject* mp_getcreates(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Get '__creates__' boolean, which determines ownership of return values. return PyInt_FromLong((long)IsCreator(pymeth->fMethodInfo->fFlags)); } //---------------------------------------------------------------------------- -static int mp_setcreates(CPPOverload* pymeth, PyObject* value, void*) { +static int mp_setcreates(PyObject* self, PyObject* value, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Set '__creates__' boolean, which determines ownership of return values. return set_flag(pymeth, value, CallContext::kIsCreator, "__creates__"); } //---------------------------------------------------------------------------- -static PyObject* mp_getmempolicy(CPPOverload* pymeth, void*) { +static PyObject* mp_getmempolicy(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Get '_mempolicy' enum, which determines ownership of call arguments. if (pymeth->fMethodInfo->fFlags & CallContext::kUseHeuristics) return PyInt_FromLong(CallContext::kUseHeuristics); @@ -462,7 +472,8 @@ static PyObject* mp_getmempolicy(CPPOverload* pymeth, void*) { } //---------------------------------------------------------------------------- -static int mp_setmempolicy(CPPOverload* pymeth, PyObject* value, void*) { +static int mp_setmempolicy(PyObject* self, PyObject* value, void*) { + CPPOverload* pymeth = (CPPOverload*)self; // Set '_mempolicy' enum, which determines ownership of call arguments. long mempolicy = PyLong_AsLong(value); if (mempolicy == CallContext::kUseHeuristics) { @@ -501,7 +512,8 @@ CPPJIT_BOOLEAN_PROPERTY(useffi, CallContext::kUseFFI, "__useffi__") CPPJIT_BOOLEAN_PROPERTY(sig2exc, CallContext::kProtected, "__sig2exc__") // clang-format on -static PyObject* mp_getcppname(CPPOverload* pymeth, void*) { +static PyObject* mp_getcppname(PyObject* self, void*) { + CPPOverload* pymeth = (CPPOverload*)self; if ((void*)pymeth == (void*)&CPPOverload_Type) return cpyrt_PyText_FromString("CPPOverload_Type"); diff --git a/src/cpyrt/CPPScope.cxx b/src/cpyrt/CPPScope.cxx index b58469d..30cd8ad 100644 --- a/src/cpyrt/CPPScope.cxx +++ b/src/cpyrt/CPPScope.cxx @@ -623,7 +623,8 @@ static PyObject* meta_reflex(CPPScope* klass, PyObject* args) { // quite what I'd expected of it, so the following pulls in the internal code #include "PyObjectDir27.inc" -static PyObject* meta_dir(CPPScope* klass) { +static PyObject* meta_dir(PyObject* self, PyObject*) { + CPPScope* klass = (CPPScope*)self; // Collect a list of everything (currently) available in the namespace. // The backend can filter by returning empty strings. Special care is // taken for functions, which need not be unique (overloading). @@ -673,7 +674,7 @@ static PyObject* meta_dir(CPPScope* klass) { static PyMethodDef meta_methods[] = { {(char*)"__cpp_reflex__", (PyCFunction)meta_reflex, METH_VARARGS, (char*)"C++ datamember reflection information"}, - {(char*)"__dir__", (PyCFunction)meta_dir, METH_NOARGS, nullptr}, + {(char*)"__dir__", meta_dir, METH_NOARGS, nullptr}, {(char*)nullptr, nullptr, 0, nullptr}}; //----------------------------------------------------------------------------- diff --git a/src/cpyrt/LowLevelViews.cxx b/src/cpyrt/LowLevelViews.cxx index b4b5be1..e2e4715 100644 --- a/src/cpyrt/LowLevelViews.cxx +++ b/src/cpyrt/LowLevelViews.cxx @@ -76,26 +76,23 @@ static void ll_dealloc(cpyrt::LowLevelView* pyobj) { } //---------------------------------------------------------------------------- -#define CPYRT_LL_FLAG_GETSET(name, flag, doc) \ - static PyObject* ll_get##name(cpyrt::LowLevelView* pyobj) { \ - return PyBool_FromLong((long)((intptr_t)pyobj->fBufInfo.internal & flag)); \ - } \ - \ - static int ll_set##name(cpyrt::LowLevelView* pyobj, PyObject* value, \ - void*) { \ - long settrue = PyLong_AsLong(value); \ - if (settrue == -1 && PyErr_Occurred()) { \ - PyErr_SetString(PyExc_ValueError, \ - #doc " should be either True or False"); \ - return -1; \ - } \ - \ - if ((bool)settrue) \ - (intptr_t&)pyobj->fBufInfo.internal |= flag; \ - else \ - (intptr_t&)pyobj->fBufInfo.internal &= ~flag; \ - \ - return 0; \ +#define CPYRT_LL_FLAG_GETSET(name, flag, doc) \ + static PyObject* ll_get##name(PyObject* pyobj, void*) { \ + auto* view = (cpyrt::LowLevelView*)pyobj; \ + return PyBool_FromLong((long)((intptr_t)view->fBufInfo.internal & flag)); \ + } \ + static int ll_set##name(PyObject* pyobj, PyObject* value, void*) { \ + auto* view = (cpyrt::LowLevelView*)pyobj; \ + long settrue = PyLong_AsLong(value); \ + if (settrue == -1 && PyErr_Occurred()) { \ + PyErr_SetString(PyExc_ValueError, #doc " should be either True or False"); \ + return -1; \ + } \ + if ((bool)settrue) \ + (intptr_t&)view->fBufInfo.internal |= flag; \ + else \ + (intptr_t&)view->fBufInfo.internal &= ~flag; \ + return 0; \ } // clang-format off @@ -681,8 +678,9 @@ static PyBufferProcs ll_as_buffer = { }; //--------------------------------------------------------------------------- -static PyObject* ll_shape(cpyrt::LowLevelView* self) { - Py_buffer& view = self->fBufInfo; +static PyObject* ll_shape(PyObject* self, void*) { + cpyrt::LowLevelView* inst = (cpyrt::LowLevelView*)self; + Py_buffer& view = inst->fBufInfo; PyObject* shape = PyTuple_New(view.ndim); for (Py_ssize_t idim = 0; idim < view.ndim; ++idim) @@ -692,8 +690,9 @@ static PyObject* ll_shape(cpyrt::LowLevelView* self) { } //--------------------------------------------------------------------------- -static PyObject* ll_reshape(cpyrt::LowLevelView* self, PyObject* shape) { - // Allow the user to fix up the actual (type-strided) size of the buffer. +static int ll_reshape(PyObject* self, PyObject* shape, void*) { + cpyrt::LowLevelView* inst = (cpyrt::LowLevelView*)self; + if (!PyTuple_Check(shape)) { if (shape) { PyObject* pystr = PyObject_Str(shape); @@ -701,22 +700,22 @@ static PyObject* ll_reshape(cpyrt::LowLevelView* self, PyObject* shape) { PyErr_Format(PyExc_TypeError, "tuple object expected, received %s", cpyrt_PyText_AsStringChecked(pystr)); Py_DECREF(pystr); - return nullptr; + return -1; } } PyErr_SetString(PyExc_TypeError, "tuple object expected"); - return nullptr; + return -1; } - Py_buffer& view = self->fBufInfo; + Py_buffer& view = inst->fBufInfo; // verify size match Py_ssize_t oldsz = 0; for (Py_ssize_t idim = 0; idim < view.ndim; ++idim) { Py_ssize_t nlen = view.shape[idim]; if (nlen == cpyrt::UNKNOWN_SIZE || - nlen == INT_MAX / view.itemsize /* fake 'max' */) { - oldsz = -1; // meaning, unable to check size match + nlen == INT_MAX / view.itemsize) { + oldsz = -1; break; } oldsz += view.shape[idim]; @@ -732,11 +731,11 @@ static PyObject* ll_reshape(cpyrt::LowLevelView* self, PyObject* shape) { "cannot reshape array of size %ld into shape %s", (long)oldsz, cpyrt_PyText_AsString(tas)); Py_DECREF(tas); - return nullptr; + return -1; } } - // reshape + // reshape layout logic... size_t itemsize = view.strides[view.ndim - 1]; if (view.ndim != PyTuple_GET_SIZE(shape)) { PyMem_Free(view.shape); @@ -750,7 +749,7 @@ static PyObject* ll_reshape(cpyrt::LowLevelView* self, PyObject* shape) { for (Py_ssize_t idim = 0; idim < PyTuple_GET_SIZE(shape); ++idim) { Py_ssize_t nlen = PyInt_AsSsize_t(PyTuple_GET_ITEM(shape, idim)); if (nlen == -1 && PyErr_Occurred()) - return nullptr; + return -1; if (idim == 0) view.len = nlen * view.itemsize; @@ -758,14 +757,21 @@ static PyObject* ll_reshape(cpyrt::LowLevelView* self, PyObject* shape) { view.shape[idim] = nlen; } - set_strides(view, itemsize, false /* by definition not fixed */); + set_strides(view, itemsize, false); + return 0; // Success +} + +static PyObject* ll_reshape(PyObject* self, PyObject* shape) { + if (ll_reshape(self, shape, nullptr) < 0) { + return nullptr; + } Py_RETURN_NONE; } //--------------------------------------------------------------------------- -static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, - PyObject* kwds) { +static PyObject* ll_array(PyObject* self, PyObject* args) { + cpyrt::LowLevelView* inst = (cpyrt::LowLevelView*)self; // Construct a numpy array from the lowlevelview (w/o copy if possible); this // uses the Python methods to avoid depending on numpy directly @@ -775,17 +781,6 @@ static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, return nullptr; bool docopy = false; - if (kwds) { - PyObject* pycp = PyObject_GetItem(kwds, cpyrt::PyStrings::gCopy); - if (!pycp) { - PyErr_SetString(PyExc_TypeError, - "__array__ only supports the \"copy\" keyword"); - return nullptr; - } - - docopy = PyObject_IsTrue(pycp); - Py_DECREF(pycp); - } if (!docopy) { // view requested // expect possible dtype from the arguments, otherwise take it from the type @@ -793,7 +788,7 @@ static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, PyObject* dtype; if (!args || PyTuple_GET_SIZE(args) != 1) { PyObject* npdtype = PyObject_GetAttr(npmod, cpyrt::PyStrings::gDType); - PyObject* typecode = ll_typecode(self, nullptr); + PyObject* typecode = ll_typecode(inst, nullptr); dtype = PyObject_CallFunctionObjArgs(npdtype, typecode, nullptr); Py_DECREF(typecode); Py_DECREF(npdtype); @@ -807,7 +802,7 @@ static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, PyObject* npfrombuf = PyObject_GetAttr(npmod, cpyrt::PyStrings::gFromBuffer); - PyObject* view = PyObject_CallFunctionObjArgs(npfrombuf, (PyObject*)self, + PyObject* view = PyObject_CallFunctionObjArgs(npfrombuf, (PyObject*)inst, dtype, nullptr); Py_DECREF(dtype); Py_DECREF(npfrombuf); @@ -817,7 +812,7 @@ static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, } else { // copy requested PyObject* npcopy = PyObject_GetAttr(npmod, cpyrt::PyStrings::gCopy); PyObject* newarr = - PyObject_CallFunctionObjArgs(npcopy, (PyObject*)self, nullptr); + PyObject_CallFunctionObjArgs(npcopy, (PyObject*)inst, nullptr); Py_DECREF(npcopy); return newarr; @@ -828,9 +823,10 @@ static PyObject* ll_array(cpyrt::LowLevelView* self, PyObject* args, } //--------------------------------------------------------------------------- -static PyObject* ll_as_string(cpyrt::LowLevelView* self) { +static PyObject* ll_as_string(PyObject* self, PyObject* /*args*/) { + cpyrt::LowLevelView* inst = (cpyrt::LowLevelView*)self; // Interpret memory as a null-terminated char string. - Py_buffer& view = self->fBufInfo; + Py_buffer& view = inst->fBufInfo; if (strcmp(view.format, "b") != 0 || view.ndim != 1) { PyErr_Format( @@ -840,19 +836,19 @@ static PyObject* ll_as_string(cpyrt::LowLevelView* self) { return nullptr; } - char* buf = (char*)self->get_buf(); + char* buf = (char*)inst->get_buf(); size_t sz = strnlen(buf, (size_t)view.shape[0]); return cpyrt_PyText_FromStringAndSize(buf, sz); } //--------------------------------------------------------------------------- static PyMethodDef ll_methods[] = { - {(char*)"reshape", (PyCFunction)ll_reshape, METH_O, + {(char*)"reshape", ll_reshape, METH_O, (char*)"change the shape (not layout) of the low level view"}, - {(char*)"as_string", (PyCFunction)ll_as_string, METH_NOARGS, + {(char*)"as_string", ll_as_string, METH_NOARGS, (char*)"interpret memory as a null-terminated char string and return " "Python str"}, - {(char*)"__array__", (PyCFunction)ll_array, METH_VARARGS | METH_KEYWORDS, + {(char*)"__array__", ll_array, METH_VARARGS, (char*)"return a numpy array from the low level view"}, {(char*)nullptr, nullptr, 0, nullptr}}; diff --git a/src/cpyrt/MemoryRegulator.cxx b/src/cpyrt/MemoryRegulator.cxx index 6ea7671..69d45ea 100644 --- a/src/cpyrt/MemoryRegulator.cxx +++ b/src/cpyrt/MemoryRegulator.cxx @@ -52,7 +52,9 @@ struct Initcpyrt_NoneType_t { cpyrt_NoneType.tp_repr = Py_TYPE(Py_None)->tp_repr; cpyrt_NoneType.tp_richcompare = (richcmpfunc)&Initcpyrt_NoneType_t::RichCompare; - cpyrt_NoneType.tp_hash = (hashfunc)&Initcpyrt_NoneType_t::PtrHash; + + // Assigned directly without a cast + cpyrt_NoneType.tp_hash = PtrHash; cpyrt_NoneType.tp_as_mapping = &cpyrt_NoneType_mapping; @@ -60,7 +62,8 @@ struct Initcpyrt_NoneType_t { } static void DeAlloc(PyObject* pyobj) { Py_TYPE(pyobj)->tp_free(pyobj); } - static int PtrHash(PyObject* pyobj) { return (int)ptrdiff_t(pyobj); } + // Return Py_hash_t instead of int to match hashfunc signature natively + static Py_hash_t PtrHash(PyObject* pyobj) { return (Py_hash_t)pyobj; } static PyObject* RichCompare(PyObject*, PyObject* other, int opid) { return PyObject_RichCompare(other, Py_None, opid); diff --git a/src/cpyrt/Pythonize.cxx b/src/cpyrt/Pythonize.cxx index e14067c..91348ec 100644 --- a/src/cpyrt/Pythonize.cxx +++ b/src/cpyrt/Pythonize.cxx @@ -209,7 +209,7 @@ PyObject* FollowGetAttr(PyObject* self, PyObject* name) { } //- pointer checking bool converter ------------------------------------------- -PyObject* NullCheckBool(PyObject* self) { +PyObject* NullCheckBool(PyObject* self, PyObject* Py_UNUSED(args)) { if (!CPPInstance_Check(self)) { PyErr_SetString(PyExc_TypeError, "C++ object proxy expected"); return nullptr; @@ -438,7 +438,7 @@ static bool FillVector(PyObject* vecin, PyObject* args, ItemGetter* getter) { return fill_ok; } -PyObject* VectorIAdd(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* VectorIAdd(PyObject* self, PyObject* args) { // Implement fast __iadd__ on std::vector (generic __iadd__ is in Python) ItemGetter* getter = GetGetter(args); @@ -474,7 +474,7 @@ PyObject* VectorIAdd(PyObject* self, PyObject* args, PyObject* /* kwds */) { return nullptr; // error already set } -PyObject* VectorInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* VectorInit(PyObject* self, PyObject* args) { // Specialized vector constructor to allow construction from containers; // allowing such construction from initializer_list instead would possible, // but can be error-prone. This use case is common enough for std::vector to @@ -538,10 +538,10 @@ PyObject* VectorData(PyObject* self, PyObject*) { } //--------------------------------------------------------------------------- -PyObject* VectorArray(PyObject* self, PyObject* args, PyObject* kwargs) { +PyObject* VectorArray(PyObject* self, PyObject* args) { PyObject* pydata = VectorData(self, nullptr); PyObject* arrcall = PyObject_GetAttr(pydata, PyStrings::gArray); - PyObject* newarr = PyObject_Call(arrcall, args, kwargs); + PyObject* newarr = PyObject_Call(arrcall, args, nullptr); Py_DECREF(arrcall); Py_DECREF(pydata); return newarr; @@ -778,7 +778,7 @@ PyObject* VectorBoolSetItem(CPPInstance* self, PyObject* args) { } //- array behavior as primitives ---------------------------------------------- -PyObject* ArrayInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* ArrayInit(PyObject* self, PyObject* args) { // std::array is normally only constructed using aggregate initialization, // which is a concept that does not exist in python, so use this custom // constructor to to fill the array using setitem @@ -867,7 +867,7 @@ static PyObject* MapFromPairs(PyObject* self, PyObject* pairs) { return result; } -PyObject* MapInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* MapInit(PyObject* self, PyObject* args) { // Specialized map constructor to allow construction from mapping containers // and from tuples of pairs ("initializer_list style"). @@ -941,7 +941,7 @@ PyObject* STLContainsWithFind(PyObject* self, PyObject* obj) { } //- set behavior as primitives ------------------------------------------------ -PyObject* SetInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* SetInit(PyObject* self, PyObject* args) { // Specialized set constructor to allow construction from Python sets. if (PyTuple_GET_SIZE(args) == 1 && PySet_Check(PyTuple_GET_ITEM(args, 0))) { PyObject* pyset = PyTuple_GET_ITEM(args, 0); @@ -993,9 +993,9 @@ static const ptrdiff_t PS_END_ADDR = 7; // non-aligned address, so no clash static const ptrdiff_t PS_FLAG_ADDR = 11; // id. static const ptrdiff_t PS_COLL_ADDR = 13; // id. -PyObject* STLIterNext(PyObject* self); // defined below; used by STLSequenceIter +PyObject* STLIterNext(PyObject* self, PyObject* Py_UNUSED(args)); // defined below; used by STLSequenceIter -PyObject* LLSequenceIter(PyObject* self) { +PyObject* LLSequenceIter(PyObject* self, PyObject* Py_UNUSED(args)) { // Implement python's __iter__ for low level views used through STL-type // begin()/end() PyObject* iter = PyObject_CallMethodNoArgs(self, PyStrings::gBegin); @@ -1022,7 +1022,21 @@ PyObject* LLSequenceIter(PyObject* self) { return nullptr; } -PyObject* STLSequenceIter(PyObject* self) { +static PyObject* my_iter(PyObject* self, PyObject* Py_UNUSED(args)) { + return PyObject_SelfIter(self); +} + +static PyObject* STLIterNextAdapter(PyObject *self) +{ + return STLIterNext(self, nullptr); +} + +static PyObject* LLSequenceIterAdapter(PyObject *self) +{ + return LLSequenceIter(self, nullptr); +} + +PyObject* STLSequenceIter(PyObject* self, PyObject* Py_UNUSED(args)) { // Implement python's __iter__ for std::iterator<>s PyObject* iter = PyObject_CallMethodNoArgs(self, PyStrings::gBegin); if (iter) { @@ -1040,13 +1054,13 @@ PyObject* STLSequenceIter(PyObject* self) { PyTypeObject* itype = Py_TYPE(iter); if (!PyIter_Check(iter)) { // no tp_iternext, or the // _PyObject_NextNotImplemented sentinel - itype->tp_iternext = (iternextfunc)STLIterNext; + itype->tp_iternext = (iternextfunc)STLIterNextAdapter; Utility::AddToClass((PyObject*)itype, CPPJIT__next__, - (PyCFunction)STLIterNext, METH_NOARGS); + STLIterNext, METH_NOARGS); if (!itype->tp_iter) { itype->tp_iter = (getiterfunc)PyObject_SelfIter; Utility::AddToClass((PyObject*)itype, "__iter__", - (PyCFunction)PyObject_SelfIter, METH_NOARGS); + my_iter, METH_NOARGS); } PyType_Modified(itype); } @@ -1073,9 +1087,14 @@ PyObject* STLSequenceIter(PyObject* self) { return iter; } +static PyObject* STLSequenceIterAdapter(PyObject *self) +{ + return STLSequenceIter(self, nullptr); +} + //- generic iterator support over a sequence with operator[] and size --------- //----------------------------------------------------------------------------- -static PyObject* index_iter(PyObject* c) { +static PyObject* index_iter(PyObject* c, PyObject* Py_UNUSED(args)) { indexiterobject* ii = PyObject_GC_New(indexiterobject, &IndexIter_Type); if (!ii) return nullptr; @@ -1089,6 +1108,11 @@ static PyObject* index_iter(PyObject* c) { return (PyObject*)ii; } +static PyObject* index_iterAdapter(PyObject *self) +{ + return index_iter(self, nullptr); +} + //- safe indexing for STL-like vector w/o iterator dictionaries --------------- /* replaced by indexiterobject iteration, but may still have some future use ... PyObject* CheckedGetItem(PyObject* self, PyObject* obj) @@ -1145,7 +1169,7 @@ PyObject* PairUnpack(PyObject* self, PyObject* pyindex) { PyObject* ReturnTwo(CPPInstance*, PyObject*) { return PyInt_FromLong(2); } //- shared/unique_ptr behavior ----------------------------------------------- -PyObject* SmartPtrInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* SmartPtrInit(PyObject* self, PyObject* args) { // since the shared/unique pointer will take ownership, we need to relinquish // it PyObject* realInit = PyObject_GetAttr(self, PyStrings::gRealInit); @@ -1198,7 +1222,7 @@ static inline PyObject* cpyrt_PyString_FromCppString(std::wstring_view s, return nullptr; \ } \ \ - PyObject* name##StringStr(PyObject* self) { \ + PyObject* name##StringStr(PyObject* self, PyObject* Py_UNUSED(args)) { \ PyObject* pyobj = name##StringGetData(self, false); \ if (!pyobj) { \ /* do a native conversion to make printing possible (debatable) */ \ @@ -1212,11 +1236,11 @@ static inline PyObject* cpyrt_PyString_FromCppString(std::wstring_view s, return pyobj; \ } \ \ - PyObject* name##StringBytes(PyObject* self) { \ + PyObject* name##StringBytes(PyObject* self, PyObject* Py_UNUSED(args)) { \ return name##StringGetData(self, true); \ } \ \ - PyObject* name##StringRepr(PyObject* self) { \ + PyObject* name##StringRepr(PyObject* self, PyObject* Py_UNUSED(args)) { \ PyObject* data = name##StringGetData(self, true); \ if (data) { \ PyObject* repr = PyObject_Repr(data); \ @@ -1278,16 +1302,15 @@ static inline std::string* GetSTLString(CPPInstance* self) { return obj; } -PyObject* STLStringDecode(CPPInstance* self, PyObject* args, PyObject* kwds) { - std::string* obj = GetSTLString(self); +PyObject* STLStringDecode(PyObject* self, PyObject* args) { + CPPInstance* inst = (CPPInstance*)self; + std::string* obj = GetSTLString(inst); if (!obj) return nullptr; - char* keywords[] = {(char*)"encoding", (char*)"errors", (char*)nullptr}; const char* encoding = nullptr; const char* errors = nullptr; - if (!PyArg_ParseTupleAndKeywords(args, kwds, const_cast("s|s"), - keywords, &encoding, &errors)) + if (!PyArg_ParseTuple(args, "s|s", &encoding, &errors)) return nullptr; return PyUnicode_Decode(obj->data(), obj->size(), encoding, errors); @@ -1309,9 +1332,9 @@ PyObject* STLStringContains(CPPInstance* self, PyObject* pyobj) { Py_RETURN_FALSE; } -PyObject* STLStringReplace(CPPInstance* self, PyObject* args, - PyObject* /*kwds*/) { - std::string* obj = GetSTLString(self); +PyObject* STLStringReplace(PyObject* self, PyObject* args) { + CPPInstance* inst = (CPPInstance*)self; + std::string* obj = GetSTLString(inst); if (!obj) return nullptr; @@ -1330,7 +1353,7 @@ PyObject* STLStringReplace(CPPInstance* self, PyObject* args, } PyObject* cppreplace = - PyObject_GetAttrString((PyObject*)self, (char*)"__cpp_replace"); + PyObject_GetAttrString((PyObject*)inst, (char*)"__cpp_replace"); if (cppreplace) { PyObject* result = PyObject_Call(cppreplace, args, nullptr); Py_DECREF(cppreplace); @@ -1343,14 +1366,14 @@ PyObject* STLStringReplace(CPPInstance* self, PyObject* args, } #define CPYRT_STRING_FINDMETHOD(name, cppname, pyname) \ - PyObject* STLString##name(CPPInstance* self, PyObject* args, \ - PyObject* /*kwds*/) { \ - std::string* obj = GetSTLString(self); \ + PyObject* STLString##name(PyObject* self, PyObject* args) { \ + CPPInstance* inst = (CPPInstance*) self; \ + std::string* obj = GetSTLString(inst); \ if (!obj) \ return nullptr; \ \ PyObject* cppmeth = \ - PyObject_GetAttrString((PyObject*)self, (char*)#cppname); \ + PyObject_GetAttrString((PyObject*)inst, (char*)#cppname); \ if (cppmeth) { \ PyObject* result = PyObject_Call(cppmeth, args, nullptr); \ Py_DECREF(cppmeth); \ @@ -1392,7 +1415,7 @@ PyObject* STLStringGetAttr(CPPInstance* self, PyObject* attr_name) { return attr; } -PyObject* UTF8Repr(PyObject* self) { +PyObject* UTF8Repr(PyObject* self, PyObject* Py_UNUSED(args)) { // force C++ string types conversion to Python str per Python __repr__ // requirements PyObject* res = PyObject_CallMethodNoArgs(self, PyStrings::gCppRepr); @@ -1403,7 +1426,7 @@ PyObject* UTF8Repr(PyObject* self) { return str_res; } -PyObject* UTF8Str(PyObject* self) { +PyObject* UTF8Str(PyObject* self, PyObject* Py_UNUSED(args)) { // force C++ string types conversion to Python str per Python __str__ // requirements PyObject* res = PyObject_CallMethodNoArgs(self, PyStrings::gCppStr); @@ -1424,7 +1447,7 @@ Py_hash_t STLStringHash(PyObject* self) { } //- string_view behavior as primitive ---------------------------------------- -PyObject* StringViewInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { +PyObject* StringViewInit(PyObject* self, PyObject* args) { // if constructed from a Python unicode object, the constructor will convert // it to a temporary byte string, which is likely to go out of scope too soon; // so buffer it as needed @@ -1464,7 +1487,7 @@ PyObject* StringViewInit(PyObject* self, PyObject* args, PyObject* /* kwds */) { } //- STL iterator behavior ---------------------------------------------------- -PyObject* STLIterNext(PyObject* self) { +PyObject* STLIterNext(PyObject* self, PyObject* Py_UNUSED(args)) { // Python iterator protocol __next__ for STL forward iterators. bool mustIncrement = true; PyObject* last = nullptr; @@ -1536,7 +1559,7 @@ PyObject* STLIterNext(PyObject* self) { COMPLEX_METH_GETSET(real, PyStrings::gCppReal) COMPLEX_METH_GETSET(imag, PyStrings::gCppImag) -static PyObject* ComplexComplex(PyObject* self) { +static PyObject* ComplexComplex(PyObject* self, PyObject* Py_UNUSED(args)) { PyObject* real = PyObject_CallMethodNoArgs(self, PyStrings::gCppReal); if (!real) return nullptr; @@ -1556,7 +1579,7 @@ static PyObject* ComplexComplex(PyObject* self) { return PyComplex_FromDoubles(r, i); } -static PyObject* ComplexRepr(PyObject* self) { +static PyObject* ComplexRepr(PyObject* self, PyObject* Py_UNUSED(args)) { PyObject* real = PyObject_CallMethodNoArgs(self, PyStrings::gCppReal); if (!real) return nullptr; @@ -1608,9 +1631,10 @@ static int ComplexDImagSet(CPPInstance* self, PyObject* value, void*) { PyGetSetDef ComplexDImag{(char*)"imag", (getter)ComplexDImagGet, (setter)ComplexDImagSet, nullptr, nullptr}; -static PyObject* ComplexDComplex(CPPInstance* self) { - double r = ((std::complex*)self->GetObject())->real(); - double i = ((std::complex*)self->GetObject())->imag(); +static PyObject* ComplexDComplex(PyObject* self, PyObject* Py_UNUSED(args)) { + CPPInstance* inst = (CPPInstance*)self; + double r = ((std::complex*)inst->GetObject())->real(); + double i = ((std::complex*)inst->GetObject())->imag(); return PyComplex_FromDoubles(r, i); } @@ -1671,7 +1695,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { // for pre-check of nullptr for boolean types if (HasAttrDirect(pyclass, PyStrings::gCppBool)) { const char* pybool_name = "__bool__"; - Utility::AddToClass(pyclass, pybool_name, (PyCFunction)NullCheckBool, + Utility::AddToClass(pyclass, pybool_name, NullCheckBool, METH_NOARGS); } @@ -1708,8 +1732,8 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { if (isIterator) { // install iterator protocol a la STL - ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)STLSequenceIter; - Utility::AddToClass(pyclass, "__iter__", (PyCFunction)STLSequenceIter, + ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)STLSequenceIterAdapter; + Utility::AddToClass(pyclass, "__iter__", STLSequenceIter, METH_NOARGS); } else { // still okay if this is some pointer type of builtin persuasion @@ -1718,9 +1742,9 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { std::string resolved = interop::ResolveName(resname); if (resolved.back() == '*' && interop::IsBuiltin(resolved.substr(0, resolved.size() - 1))) { - ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)LLSequenceIter; + ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)LLSequenceIterAdapter; Utility::AddToClass(pyclass, "__iter__", - (PyCFunction)LLSequenceIter, METH_NOARGS); + LLSequenceIter, METH_NOARGS); } } } @@ -1733,8 +1757,8 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { // if beyond size()) works in some cases but would mess up if operator[] // is meant to implement an associative container. So, this has to be // implemented as an iterator protocol. - ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)index_iter; - Utility::AddToClass(pyclass, "__iter__", (PyCFunction)index_iter, + ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)index_iterAdapter; + Utility::AddToClass(pyclass, "__iter__", index_iter, METH_NOARGS); } } @@ -1780,14 +1804,14 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { if (HasAttrDirect(pyclass, PyStrings::gRepr, true)) { // guarantee that the result of __repr__ is a Python string Utility::AddToClass(pyclass, "__cpp_repr", "__repr__"); - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)UTF8Repr, + Utility::AddToClass(pyclass, "__repr__", UTF8Repr, METH_NOARGS); } if (HasAttrDirect(pyclass, PyStrings::gStr, true)) { // guarantee that the result of __str__ is a Python string Utility::AddToClass(pyclass, "__cpp_str", "__str__"); - Utility::AddToClass(pyclass, "__str__", (PyCFunction)UTF8Str, METH_NOARGS); + Utility::AddToClass(pyclass, "__str__", UTF8Str, METH_NOARGS); } if (interop::IsAggregate(((CPPClass*)pyclass)->fCppType) && @@ -1894,7 +1918,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { } else { // constructor that takes python collections Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)VectorInit, + Utility::AddToClass(pyclass, "__init__", VectorInit, METH_VARARGS | METH_KEYWORDS); // data with size @@ -1903,8 +1927,8 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { Utility::AddToClass(pyclass, "data", (PyCFunction)VectorData); // numpy array conversion - Utility::AddToClass(pyclass, "__array__", (PyCFunction)VectorArray, - METH_VARARGS | METH_KEYWORDS /* unused */); + Utility::AddToClass(pyclass, "__array__", VectorArray, + METH_VARARGS); // checked getitem if (HasAttrDirect(pyclass, PyStrings::gLen)) { @@ -1917,7 +1941,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)vector_iter; // optimized __iadd__ - Utility::AddToClass(pyclass, "__iadd__", (PyCFunction)VectorIAdd, + Utility::AddToClass(pyclass, "__iadd__", VectorIAdd, METH_VARARGS | METH_KEYWORDS); // helpers for iteration @@ -1946,7 +1970,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { else if (IsTemplatedSTLClass(name, "array")) { // constructor that takes python associative collections Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)ArrayInit, + Utility::AddToClass(pyclass, "__init__", ArrayInit, METH_VARARGS | METH_KEYWORDS); } @@ -1954,7 +1978,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { IsTemplatedSTLClass(name, "unordered_map")) { // constructor that takes python associative collections Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)MapInit, + Utility::AddToClass(pyclass, "__init__", MapInit, METH_VARARGS | METH_KEYWORDS); // From C++20, std::map/unordered_map have a native contains() that the // generic contains->__contains__ mapping above will pick up. Strong-types @@ -1969,7 +1993,7 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { else if (IsTemplatedSTLClass(name, "set")) { // constructor that takes python associative collections Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)SetInit, + Utility::AddToClass(pyclass, "__init__", SetInit, METH_VARARGS | METH_KEYWORDS); // From C++20, std::set has a native contains() that the generic // contains->__contains__ mapping above will pick up. Strong-types @@ -1990,18 +2014,18 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { if (IsTemplatedSTLClass(name, "shared_ptr") || IsTemplatedSTLClass(name, "unique_ptr")) { Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)SmartPtrInit, + Utility::AddToClass(pyclass, "__init__", SmartPtrInit, METH_VARARGS | METH_KEYWORDS); } else if (!((PyTypeObject*)pyclass)->tp_iter && (name.find("iterator") != std::string::npos || gIteratorTypes.find(name) != gIteratorTypes.end())) { - ((PyTypeObject*)pyclass)->tp_iternext = (iternextfunc)STLIterNext; - Utility::AddToClass(pyclass, CPPJIT__next__, (PyCFunction)STLIterNext, + ((PyTypeObject*)pyclass)->tp_iternext = (iternextfunc)STLIterNextAdapter; + Utility::AddToClass(pyclass, CPPJIT__next__, STLIterNext, METH_NOARGS); ((PyTypeObject*)pyclass)->tp_iter = (getiterfunc)PyObject_SelfIter; - Utility::AddToClass(pyclass, "__iter__", (PyCFunction)PyObject_SelfIter, + Utility::AddToClass(pyclass, "__iter__", my_iter, METH_NOARGS); } @@ -2009,11 +2033,11 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { name == "std::__1::basic_string" || // libc++ inline namespace name == "std::string") { // typedef preserved by GetScopedFinalName // on libc++ - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)STLStringRepr, + Utility::AddToClass(pyclass, "__repr__", STLStringRepr, METH_NOARGS); - Utility::AddToClass(pyclass, "__str__", (PyCFunction)STLStringStr, + Utility::AddToClass(pyclass, "__str__", STLStringStr, METH_NOARGS); - Utility::AddToClass(pyclass, "__bytes__", (PyCFunction)STLStringBytes, + Utility::AddToClass(pyclass, "__bytes__", STLStringBytes, METH_NOARGS); Utility::AddToClass(pyclass, "__cmp__", (PyCFunction)STLStringCompare, METH_O); @@ -2027,16 +2051,16 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { // wrongly dropped it when built with -std=c++2c (__cplusplus == 202400L). Utility::AddToClass(pyclass, "__contains__", (PyCFunction)STLStringContains, METH_O); - Utility::AddToClass(pyclass, "decode", (PyCFunction)STLStringDecode, - METH_VARARGS | METH_KEYWORDS); + Utility::AddToClass(pyclass, "decode", STLStringDecode, + METH_VARARGS); Utility::AddToClass(pyclass, "__cpp_find", "find"); - Utility::AddToClass(pyclass, "find", (PyCFunction)STLStringFind, + Utility::AddToClass(pyclass, "find", STLStringFind, METH_VARARGS | METH_KEYWORDS); Utility::AddToClass(pyclass, "__cpp_rfind", "rfind"); - Utility::AddToClass(pyclass, "rfind", (PyCFunction)STLStringRFind, + Utility::AddToClass(pyclass, "rfind", STLStringRFind, METH_VARARGS | METH_KEYWORDS); Utility::AddToClass(pyclass, "__cpp_replace", "replace"); - Utility::AddToClass(pyclass, "replace", (PyCFunction)STLStringReplace, + Utility::AddToClass(pyclass, "replace", STLStringReplace, METH_VARARGS | METH_KEYWORDS); Utility::AddToClass(pyclass, "__getattr__", (PyCFunction)STLStringGetAttr, METH_O); @@ -2051,9 +2075,9 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { name == "std::string_view") { // typedef preserved by // GetScopedFinalName on libc++ Utility::AddToClass(pyclass, "__real_init", "__init__"); - Utility::AddToClass(pyclass, "__init__", (PyCFunction)StringViewInit, + Utility::AddToClass(pyclass, "__init__", StringViewInit, METH_VARARGS | METH_KEYWORDS); - Utility::AddToClass(pyclass, "__bytes__", (PyCFunction)STLViewStringBytes, + Utility::AddToClass(pyclass, "__bytes__", STLViewStringBytes, METH_NOARGS); Utility::AddToClass(pyclass, "__cmp__", (PyCFunction)STLViewStringCompare, METH_O); @@ -2061,9 +2085,9 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { METH_O); Utility::AddToClass(pyclass, "__ne__", (PyCFunction)STLViewStringIsNotEqual, METH_O); - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)STLViewStringRepr, + Utility::AddToClass(pyclass, "__repr__", STLViewStringRepr, METH_NOARGS); - Utility::AddToClass(pyclass, "__str__", (PyCFunction)STLViewStringStr, + Utility::AddToClass(pyclass, "__str__", STLViewStringStr, METH_NOARGS); } @@ -2072,11 +2096,11 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { name == "std::__1::basic_string,std::__1::allocator >" || name == "std::wstring") { - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)STLWStringRepr, + Utility::AddToClass(pyclass, "__repr__", STLWStringRepr, METH_NOARGS); - Utility::AddToClass(pyclass, "__str__", (PyCFunction)STLWStringStr, + Utility::AddToClass(pyclass, "__str__", STLWStringStr, METH_NOARGS); - Utility::AddToClass(pyclass, "__bytes__", (PyCFunction)STLWStringBytes, + Utility::AddToClass(pyclass, "__bytes__", STLWStringBytes, METH_NOARGS); Utility::AddToClass(pyclass, "__cmp__", (PyCFunction)STLWStringCompare, METH_O); @@ -2095,9 +2119,9 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { PyObject_SetAttrString( pyclass, "imag", PyDescr_NewGetSet((PyTypeObject*)pyclass, &ComplexDImag)); - Utility::AddToClass(pyclass, "__complex__", (PyCFunction)ComplexDComplex, + Utility::AddToClass(pyclass, "__complex__", ComplexDComplex, METH_NOARGS); - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)ComplexRepr, + Utility::AddToClass(pyclass, "__repr__", ComplexRepr, METH_NOARGS); } @@ -2110,9 +2134,9 @@ bool cpyrt::Pythonize(PyObject* pyclass, interop::TCppScope_t scope) { PyObject_SetAttrString( pyclass, "imag", PyDescr_NewGetSet((PyTypeObject*)pyclass, &imagComplex)); - Utility::AddToClass(pyclass, "__complex__", (PyCFunction)ComplexComplex, + Utility::AddToClass(pyclass, "__complex__", ComplexComplex, METH_NOARGS); - Utility::AddToClass(pyclass, "__repr__", (PyCFunction)ComplexRepr, + Utility::AddToClass(pyclass, "__repr__", ComplexRepr, METH_NOARGS); } diff --git a/src/cpyrt/cpyrtModule.cxx b/src/cpyrt/cpyrtModule.cxx index b2c0733..4fb5441 100644 --- a/src/cpyrt/cpyrtModule.cxx +++ b/src/cpyrt/cpyrtModule.cxx @@ -593,7 +593,7 @@ static PyObject* addressof(PyObject* /* dummy */, PyObject* args, } //---------------------------------------------------------------------------- -static PyObject* AsCObject(PyObject* /* unused */, PyObject* args, +static PyObject* AsCObject(PyObject* args, PyObject* kwds) { // Return object proxy as an opaque CObject. void* addr = GetCPPInstanceAddress("as_cobject", args, kwds); @@ -603,7 +603,7 @@ static PyObject* AsCObject(PyObject* /* unused */, PyObject* args, } //---------------------------------------------------------------------------- -static PyObject* AsCapsule(PyObject* /* unused */, PyObject* args, +static PyObject* AsCapsule(PyObject* args, PyObject* kwds) { // Return object proxy as an opaque PyCapsule. void* addr = GetCPPInstanceAddress("as_capsule", args, kwds); @@ -613,7 +613,7 @@ static PyObject* AsCapsule(PyObject* /* unused */, PyObject* args, } //---------------------------------------------------------------------------- -static PyObject* AsCTypes(PyObject* /* unused */, PyObject* args, +static PyObject* AsCTypes(PyObject* args, PyObject* kwds) { // Return object proxy as a ctypes c_void_p void* addr = GetCPPInstanceAddress("as_ctypes", args, kwds); @@ -677,7 +677,7 @@ static PyObject* AsMemoryView(PyObject* /* unused */, PyObject* pyobject) { } //---------------------------------------------------------------------------- -static PyObject* BindObject(PyObject*, PyObject* args, PyObject* kwds) { +static PyObject* BindObject(PyObject* args, PyObject* kwds) { // From a long representing an address or a PyCapsule/CObject, bind to a // class. Py_ssize_t argc = PyTuple_GET_SIZE(args); diff --git a/test/Makefile b/test/Makefile index 0cd3372..62d1d22 100644 --- a/test/Makefile +++ b/test/Makefile @@ -22,7 +22,7 @@ dicts = $(addprefix cpp/,$(addsuffix Dict.so,$(dictnames))) all : $(dicts) PYTHON ?= python3 -cppflags= -Wall -Wextra -Werror -std=c++20 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register +cppflags= -std=c++17 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register PLATFORM := $(shell uname -s) ifeq ($(PLATFORM),Darwin) From 49d4f4f2963d6814f4e73ced74c9f61391eaae79 Mon Sep 17 00:00:00 2001 From: mcbarton Date: Tue, 1 Sep 2026 14:43:49 +0100 Subject: [PATCH 16/17] Fixes --- CMakeLists.txt | 2 +- test/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7722c04..004b86a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -142,7 +142,7 @@ target_include_directories(cppjit PRIVATE ) target_compile_options(cppjit PRIVATE - -Wall -Wextra -Wno-strict-aliasing -Wno-register -Werror + -Wall -Wextra -Wno-strict-aliasing -Wno-register ) if(CMAKE_COMPILER_IS_GNUCXX) diff --git a/test/Makefile b/test/Makefile index 62d1d22..a7698e2 100644 --- a/test/Makefile +++ b/test/Makefile @@ -22,7 +22,7 @@ dicts = $(addprefix cpp/,$(addsuffix Dict.so,$(dictnames))) all : $(dicts) PYTHON ?= python3 -cppflags= -std=c++17 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register +cppflags= -Wall -std=c++20 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register PLATFORM := $(shell uname -s) ifeq ($(PLATFORM),Darwin) From daa55ff46cb9bb47ce685a073d64455dc4827640 Mon Sep 17 00:00:00 2001 From: mcbarton Date: Tue, 1 Sep 2026 14:44:24 +0100 Subject: [PATCH 17/17] Fix --- test/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Makefile b/test/Makefile index a7698e2..924d62a 100644 --- a/test/Makefile +++ b/test/Makefile @@ -22,7 +22,7 @@ dicts = $(addprefix cpp/,$(addsuffix Dict.so,$(dictnames))) all : $(dicts) PYTHON ?= python3 -cppflags= -Wall -std=c++20 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register +cppflags= -Wall -std=c++17 -O3 -fPIC -I$(shell $(PYTHON) -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register PLATFORM := $(shell uname -s) ifeq ($(PLATFORM),Darwin)