refactor common nb impls

build_tools/cmake/llvm_cache.cmake

@@ -75,26 +75,7 @@ set(LLVM_INSTALL_TOOLCHAIN_ONLY OFF CACHE BOOL "")
 
 set(LLVM_DISTRIBUTIONS MlirDevelopment CACHE STRING "")
 set(LLVM_MlirDevelopment_DISTRIBUTION_COMPONENTS
-    clangAPINotes
-    clangAST
-    clangASTMatchers
-    clangAnalysis
-    clangBasic
-    clangDriver
-    clangDriver
-    clangEdit
-    clangFormat
-    clangFrontend
-    clangLex
-    clangParse
-    clangRewrite
-    clangSema
-    clangSerialization
-    clangSupport
-    clangTooling
-    clangToolingCore
-    clangToolingInclusions
-
+    clang-libraries
     clang-headers
     # triggers ClangConfig.cmake and etc
     clang-cmake-exports

projects/CMakeLists.txt

@@ -3,6 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # Copyright (c) 2024.
 
+include_directories(common)
+
 if(NOT WIN32)
   add_subdirectory(eudsl-py)
 endif()

projects/eudsl-py/src/bind_vec_like.h → projects/common/eudsl/bind_vec_like.h

@@ -1,19 +1,22 @@
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// Copyright (c) 2024.
+// Copyright (c) 2024-2025.
 
 #pragma once
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/TypeName.h"
 
 #include <algorithm>
 #include <nanobind/make_iterator.h>
 #include <nanobind/nanobind.h>
 #include <nanobind/operators.h>
 #include <nanobind/stl/bind_vector.h>
 #include <nanobind/stl/detail/traits.h>
+#include <nanobind/typing.h>
 
+namespace eudsl {
 struct _ArrayRef {};
 struct _MutableArrayRef {};
 struct _SmallVector {};
@@ -283,3 +286,18 @@ nanobind::class_<Vector> bind_iter_range(nanobind::handle scope,
 
   return cl;
 }
+
+inline void bind_array_ref_smallvector(nanobind::handle scope) {
+  scope.attr("T") = nanobind::type_var("T");
+  arrayRef =
+      nanobind::class_<_ArrayRef>(scope, "ArrayRef", nanobind::is_generic(),
+                                  nanobind::sig("class ArrayRef[T]"));
+  mutableArrayRef = nanobind::class_<_MutableArrayRef>(
+      scope, "MutableArrayRef", nanobind::is_generic(),
+      nanobind::sig("class MutableArrayRef[T]"));
+  smallVector = nanobind::class_<_SmallVector>(
+      scope, "SmallVector", nanobind::is_generic(),
+      nanobind::sig("class SmallVector[T]"));
+}
+
+} // namespace eudsl

projects/eudsl-py/src/type_casters.h → projects/common/eudsl/type_casters.h

@@ -1,14 +1,20 @@
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// Copyright (c) 2024.
+// Copyright (c) 2024-2025.
 
 #pragma once
 
 #include <nanobind/nanobind.h>
-#include <nanobind/stl/optional.h>
+// ReSharper disable once CppUnusedIncludeDirective
 #include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+// ReSharper disable once CppUnusedIncludeDirective
 #include <nanobind/stl/unique_ptr.h>
+// ReSharper disable once CppUnusedIncludeDirective
+#include <nanobind/stl/optional.h>
+// ReSharper disable once CppUnusedIncludeDirective
+#include "eudsl/bind_vec_like.h"
 
 template <>
 struct nanobind::detail::type_caster<llvm::StringRef> {

projects/common/eudsl/util.h

@@ -0,0 +1,103 @@
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// Copyright (c) 2025.
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+namespace eudsl {
+template <typename T, typename... Ts>
+struct non_copying_non_moving_class_ : nanobind::class_<T, Ts...> {
+  template <typename... Extra>
+  NB_INLINE non_copying_non_moving_class_(nanobind::handle scope,
+                                          const char *name,
+                                          const Extra &...extra) {
+    nanobind::detail::type_init_data d;
+
+    d.flags = 0;
+    d.align = (uint8_t)alignof(typename nanobind::class_<T, Ts...>::Alias);
+    d.size = (uint32_t)sizeof(typename nanobind::class_<T, Ts...>::Alias);
+    d.name = name;
+    d.scope = scope.ptr();
+    d.type = &typeid(T);
+
+    if constexpr (!std::is_same_v<typename nanobind::class_<T, Ts...>::Base,
+                                  T>) {
+      d.base = &typeid(typename nanobind::class_<T, Ts...>::Base);
+      d.flags |= (uint32_t)nanobind::detail::type_init_flags::has_base;
+    }
+
+    if constexpr (std::is_destructible_v<T>) {
+      d.flags |= (uint32_t)nanobind::detail::type_flags::is_destructible;
+
+      if constexpr (!std::is_trivially_destructible_v<T>) {
+        d.flags |= (uint32_t)nanobind::detail::type_flags::has_destruct;
+        d.destruct = nanobind::detail::wrap_destruct<T>;
+      }
+    }
+
+    if constexpr (nanobind::detail::has_shared_from_this_v<T>) {
+      d.flags |= (uint32_t)nanobind::detail::type_flags::has_shared_from_this;
+      d.keep_shared_from_this_alive = [](PyObject *self) noexcept {
+        if (auto sp = nanobind::inst_ptr<T>(self)->weak_from_this().lock()) {
+          nanobind::detail::keep_alive(
+              self, new auto(std::move(sp)),
+              [](void *p) noexcept { delete (decltype(sp) *)p; });
+          return true;
+        }
+        return false;
+      };
+    }
+
+    (nanobind::detail::type_extra_apply(d, extra), ...);
+
+    this->m_ptr = nanobind::detail::nb_type_new(&d);
+  }
+};
+
+template <typename NewReturn, typename Return, typename... Args>
+constexpr auto coerceReturn(Return (*pf)(Args...)) noexcept {
+  return [&pf](Args &&...args) -> NewReturn {
+    return pf(std::forward<Args>(args)...);
+  };
+}
+
+template <typename NewReturn, typename Return, typename Class, typename... Args>
+constexpr auto coerceReturn(Return (Class::*pmf)(Args...),
+                            std::false_type = {}) noexcept {
+  return [&pmf](Class *cls, Args &&...args) -> NewReturn {
+    return (cls->*pmf)(std::forward<Args>(args)...);
+  };
+}
+
+/*
+ * If you get
+ * ```
+ * Called object type 'void(MyClass::*)(vector<Item>&,int)' is not a function or
+ * function pointer
+ * ```
+ * it's because you're calling a member function without
+ * passing the `this` pointer as the first arg
+ */
+template <typename NewReturn, typename Return, typename Class, typename... Args>
+constexpr auto coerceReturn(Return (Class::*pmf)(Args...) const,
+                            std::true_type) noexcept {
+  // copy the *pmf, not capture by ref
+  return [pmf](const Class &cls, Args &&...args) -> NewReturn {
+    return (cls.*pmf)(std::forward<Args>(args)...);
+  };
+}
+
+inline size_t wrap(Py_ssize_t i, size_t n) {
+  if (i < 0)
+    i += (Py_ssize_t)n;
+
+  if (i < 0 || (size_t)i >= n)
+    throw nanobind::index_error();
+
+  return (size_t)i;
+}
+
+} // namespace eudsl

projects/eudsl-nbgen/CMakeLists.txt

@@ -31,6 +31,8 @@ if(EUDSL_NBGEN_STANDALONE_BUILD)
   include(AddLLVM)
   include(AddClang)
   include(HandleLLVMOptions)
+
+  include_directories(${CMAKE_CURRENT_LIST_DIR}/../common)
 endif()
 
 include_directories(${LLVM_INCLUDE_DIRS})

projects/eudsl-nbgen/cmake/eudsl_nbgen-config.cmake

@@ -5,6 +5,19 @@
 
 # copy-pasta from AddMLIR.cmake/AddLLVM.cmake/TableGen.cmake
 
+set(EUDSL_NBGEN_NANOBIND_OPTIONS
+  -Wno-cast-qual
+  -Wno-deprecated-literal-operator
+  -Wno-covered-switch-default
+  -Wno-nested-anon-types
+  -Wno-zero-length-array
+  -Wno-c++98-compat-extra-semi
+  -Wno-c++20-extensions
+  $<$<PLATFORM_ID:Linux>:-fexceptions -frtti>
+  $<$<PLATFORM_ID:Darwin>:-fexceptions -frtti>
+  $<$<PLATFORM_ID:Windows>:/EHsc /GR>
+)
+
 function(eudsl_nbgen target input_file)
   set(EUDSL_NBGEN_TARGET_DEFINITIONS ${input_file})
   cmake_parse_arguments(ARG "" "" "LINK_LIBS;EXTRA_INCLUDES;NAMESPACES" ${ARGN})
@@ -89,6 +102,7 @@ function(eudsl_nbgen target input_file)
       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
       DEPENDS ${EUDSL_NBGEN_EXE} ${global_tds}
       DEPFILE ${_depfile}
+      DEPENDS ${EUDSL_NBGEN_EXE}
       COMMENT "eudsl-nbgen: Generating ${_full_gen_file}..."
     )
     # epic hack to specify all shards that will be generated even though we don't know them before hand
@@ -137,6 +151,7 @@ function(eudsl_nbgen target input_file)
   endif()
 
   add_library(${target} STATIC "${_full_gen_file}.sharded.cpp" ${_shards})
+  target_compile_options(${target} PUBLIC ${EUDSL_NBGEN_NANOBIND_OPTIONS})
   execute_process(
     COMMAND "${Python_EXECUTABLE}" -m nanobind --include_dir
     OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_include_dir