tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/runtime/cpp/include/tpy/type_traits.hpp

@@ -0,0 +1,240 @@
+/**
+ * TurboPython Runtime - Type Traits
+ *
+ * Compile-time type classification for value vs reference semantics.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace tpy {
+
+// Forward declaration for BigInt specialization
+class BigInt;
+
+// --- Type trait for value vs reference semantics ---
+
+/**
+ * is_value_type - Type trait for determining copy vs reference semantics.
+ *
+ * Value types (primitives) are returned by copy when accessed from containers.
+ * Object types (records, nested containers) are returned by reference.
+ */
+template<typename T> struct is_value_type : std::false_type {};
+
+// const-qualified types share their unqualified value-ness, so a readonly
+// `*args` param lowered to `varargs<const T>` selects the same specialization
+// (value vs dual-mode) as the mutable `varargs<T>`.
+template<typename T> struct is_value_type<const T> : is_value_type<T> {};
+
+// Primitive value types
+template<> struct is_value_type<int8_t> : std::true_type {};
+template<> struct is_value_type<int16_t> : std::true_type {};
+template<> struct is_value_type<int32_t> : std::true_type {};
+template<> struct is_value_type<int64_t> : std::true_type {};
+template<> struct is_value_type<uint8_t> : std::true_type {};
+template<> struct is_value_type<uint16_t> : std::true_type {};
+template<> struct is_value_type<uint32_t> : std::true_type {};
+template<> struct is_value_type<uint64_t> : std::true_type {};
+template<> struct is_value_type<bool> : std::true_type {};
+template<> struct is_value_type<char> : std::true_type {};
+template<> struct is_value_type<double> : std::true_type {};
+template<> struct is_value_type<std::string> : std::true_type {};
+template<> struct is_value_type<std::string_view> : std::true_type {};
+template<> struct is_value_type<BigInt> : std::true_type {};
+// std::monostate -- TPy NoneType at value-bearing positions (e.g. Future[None]).
+// Pure unit type, trivially copyable; passes through containers and generics
+// the same way primitives do.
+template<> struct is_value_type<std::monostate> : std::true_type {};
+
+// Forward declaration for SpanIter specialization
+template<typename T> struct SpanIter;
+
+// SpanIter is a lightweight view (span + index), passed by value but borrows
+template<typename T> struct is_value_type<SpanIter<T>> : std::true_type {};
+
+// Tuples are value types (immutable in Python, always copied/moved)
+template<typename... Ts> struct is_value_type<std::tuple<Ts...>> : std::true_type {};
+
+// val_or_ref<T> is a lightweight pointer/value wrapper, always passed by value
+template<typename T> struct val_or_ref;
+template<typename T> struct is_value_type<val_or_ref<T>> : std::true_type {};
+
+template<typename T>
+inline constexpr bool is_value_type_v = is_value_type<T>::value;
+
+// C++ concept for the ValueType marker protocol
+template<typename T>
+concept ValueType = is_value_type_v<T>;
+
+// C++ concept for the Copyable marker protocol. Maps to copy-constructibility,
+// which is the operation a generic method like Box[T].clone() actually needs.
+// std::copy_constructible would also require move-constructibility; we want
+// just the copy step here, so check the trait directly. Two theoretical edge
+// cases the trait admits but std::copy_constructible would reject: types with
+// an `explicit`-only copy ctor (direct-init works, copy-init doesn't) and
+// types that are copy-constructible but not destructible. Neither pattern is
+// generated by TPy today; if @native ever introduces one, switch to the
+// standard concept or add a static_assert in the requires-clause emit path.
+template<typename T>
+concept Copyable = std::is_copy_constructible_v<T>;
+
+// --- Thread safety markers ---
+
+/**
+ * is_send - Type trait for thread-safe ownership transfer.
+ *
+ * Send types can be safely moved to another thread. All value types are Send
+ * by default. Raw pointers and non-owning views are not Send.
+ * User records specialize this trait when auto-derived by the compiler.
+ */
+template<typename T> struct is_send : is_value_type<T> {};
+
+// Pointers are not Send (raw pointer, no ownership guarantee)
+template<typename T> struct is_send<T*> : std::false_type {};
+template<typename T> struct is_send<const T*> : std::false_type {};
+
+// string_view is not Send (borrows from another string)
+template<> struct is_send<std::string_view> : std::false_type {};
+
+// SpanIter borrows from a span -- not safe to transfer or share
+template<typename T> struct is_send<SpanIter<T>> : std::false_type {};
+
+// Containers: Send if elements are Send
+template<typename T, typename A> struct is_send<std::vector<T, A>> : is_send<T> {};
+template<typename T, std::size_t N> struct is_send<std::array<T, N>> : is_send<T> {};
+
+// Forward declarations for container specializations
+template<typename K, typename V> class ordered_map;
+template<typename T> class ordered_set;
+
+// ordered_map: Send if both key and value are Send
+template<typename K, typename V>
+struct is_send<ordered_map<K, V>>
+    : std::bool_constant<is_send<K>::value && is_send<V>::value> {};
+
+// ordered_set: Send if element is Send
+template<typename T>
+struct is_send<ordered_set<T>> : is_send<T> {};
+
+template<typename T>
+concept Send = is_send<T>::value;
+
+/**
+ * is_sync - Type trait for thread-safe shared access.
+ *
+ * Sync types can be safely referenced from multiple threads. Immutable types
+ * are Sync. Mutable containers (vector, ordered_map) are not Sync.
+ * User records specialize this trait when auto-derived by the compiler.
+ */
+template<typename T> struct is_sync : is_value_type<T> {};
+
+// Mutable pointers are not Sync
+template<typename T> struct is_sync<T*> : std::false_type {};
+// Const pointers are Sync if the pointee is Sync
+template<typename T> struct is_sync<const T*> : is_sync<T> {};
+
+// Mutable containers are not Sync
+template<typename T, typename A> struct is_sync<std::vector<T, A>> : std::false_type {};
+template<typename K, typename V> struct is_sync<ordered_map<K, V>> : std::false_type {};
+template<typename T> struct is_sync<ordered_set<T>> : std::false_type {};
+template<typename T, std::size_t N> struct is_sync<std::array<T, N>> : is_sync<T> {};
+
+// SpanIter has mutable index_ state, not safe to share
+template<typename T> struct is_sync<SpanIter<T>> : std::false_type {};
+
+template<typename T>
+concept Sync = is_sync<T>::value;
+
+// Dispatched through impl structs so `T = void` can be specialized;
+// `val_or_ref_t<void> = void` lets `def f[T] -> T` instantiate with
+// T=None (the naked `std::conditional_t<..., void, void&>` form would
+// substitute to ill-formed `void&`).
+namespace detail {
+    template<typename T> struct val_or_ref_impl       { using type = std::conditional_t<is_value_type<T>::value, T,        T&>; };
+    template<typename T> struct val_or_cref_impl      { using type = std::conditional_t<is_value_type<T>::value, T,        const T&>; };
+    template<typename T> struct param_val_or_ref_impl { using type = std::conditional_t<is_value_type<T>::value, const T&, T&>; };
+
+    template<> struct val_or_ref_impl<void>       { using type = void; };
+    template<> struct val_or_cref_impl<void>      { using type = void; };
+    template<> struct param_val_or_ref_impl<void> { using type = void; };
+}
+
+template<typename T> using val_or_ref_t       = typename detail::val_or_ref_impl<T>::type;
+template<typename T> using val_or_cref_t      = typename detail::val_or_cref_impl<T>::type;
+template<typename T> using param_val_or_ref_t = typename detail::param_val_or_ref_impl<T>::type;
+
+/**
+ * is_dyn_protocol_base<T> -- true iff T is a TPy @dynamic protocol abstract
+ * base. Codegen emits a specialization next to each @dynamic protocol class;
+ * default-false primary tolerates incomplete T (recursive type aliases).
+ */
+template<typename T> struct is_dyn_protocol_base : std::false_type {};
+
+template<typename T>
+inline constexpr bool is_dyn_protocol_base_v = is_dyn_protocol_base<T>::value;
+
+/**
+ * own_param_t<T> -- C++ parameter shape for a TPy Own[T] slot, picking per T
+ * at template instantiation: unique_ptr<T> for abstract @dynamic bases,
+ * T&& otherwise. Lazy via alias, so one template body handles all T.
+ */
+template<typename T>
+using own_param_t = std::conditional_t<
+    is_dyn_protocol_base_v<T>,
+    std::unique_ptr<T>,
+    T&&
+>;
+
+/**
+ * own_return_t<T> -- C++ return shape for a TPy Own[T] result.
+ *
+ * Companion to own_param_t. The param shape uses T&& for concrete T
+ * (rvalue ref to a caller-owned object), but T&& can't be a return type
+ * without dangling -- callees can't return a reference to their local.
+ * own_return_t is the by-value return shape: T for concrete (move),
+ * unique_ptr<T> for abstract @dynamic bases (ownership handle).
+ */
+template<typename T>
+using own_return_t = std::conditional_t<
+    is_dyn_protocol_base_v<T>,
+    std::unique_ptr<T>,
+    T
+>;
+
+/**
+ * val_or_ref<T> - Wrapper for iterator __next__() returns.
+ *
+ * Stores value types (int, str, tuple, ...) by value, non-value types
+ * (records, containers) by pointer. This lets __next__() return element
+ * references through std::expected (which cannot hold T&).
+ *
+ * T may be const-qualified (e.g. from a const_iterator). val_or_ref<const T>
+ * stores const T* and get() returns const T&.
+ */
+template<typename T>
+struct val_or_ref {
+    using is_val_or_ref_tag = void;
+    static constexpr bool is_val = is_value_type<std::remove_const_t<T>>::value;
+    using storage_t = std::conditional_t<is_val, std::remove_const_t<T>, T*>;
+    storage_t data_;
+
+    val_or_ref(const std::remove_const_t<T>& v) requires (is_val) : data_(v) {}
+    val_or_ref(T& ref) requires (!is_val) : data_(&ref) {}
+
+    decltype(auto) get() const {
+        if constexpr (is_val) return data_;
+        else return (*data_);
+    }
+};
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/uninit_array_storage.hpp

@@ -0,0 +1,250 @@
+/**
+ * TurboPython Runtime - UninitArrayStorage
+ *
+ * Inline uninitialized storage for N elements of type T.
+ * Uses a union so elements are not default-constructed.
+ * Caller is responsible for managing element lifetimes via
+ * construct() / destroy().
+ *
+ * Copy/move: not explicitly deleted -- C++ union rules apply naturally:
+ *   - Trivially copyable T: copy works (bytes are independent)
+ *   - Non-trivially-copyable T: C++ implicitly deletes union copy
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <new>
+#include <span>
+#include <type_traits>
+#include <utility>
+
+#include "core.hpp"
+
+#ifndef NDEBUG
+#include <bitset>
+#endif
+
+namespace tpy {
+
+template <typename T, std::size_t N>
+class UninitArrayStorage {
+public:
+    UninitArrayStorage() noexcept {
+#ifndef NDEBUG
+        alive_.reset();
+#endif
+    }
+
+    UninitArrayStorage(UninitArrayStorage&& other) noexcept {
+        std::memcpy(static_cast<void*>(&elems_[0]), static_cast<const void*>(&other.elems_[0]), sizeof(elems_));
+#ifndef NDEBUG
+        alive_ = other.alive_;
+        other.alive_.reset();
+#endif
+    }
+
+    UninitArrayStorage& operator=(UninitArrayStorage&& other) noexcept {
+        if (this != &other) {
+            std::memcpy(static_cast<void*>(&elems_[0]), static_cast<const void*>(&other.elems_[0]), sizeof(elems_));
+#ifndef NDEBUG
+            alive_ = other.alive_;
+            other.alive_.reset();
+#endif
+        }
+        return *this;
+    }
+
+    ~UninitArrayStorage() {
+#ifndef NDEBUG
+        if (alive_.any()) {
+            tpy_panic("UninitArrayStorage destroyed with live elements");
+        }
+#endif
+    }
+
+    void init(uint32_t i, T&& value) {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::init index out of bounds");
+        }
+        if (alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::init on already-alive slot");
+        }
+        alive_.set(i);
+#endif
+        ::new (static_cast<void*>(&elems_[i])) T(std::move(value));
+    }
+
+    void init(uint32_t i, const T& value) {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::init index out of bounds");
+        }
+        if (alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::init on already-alive slot");
+        }
+        alive_.set(i);
+#endif
+        ::new (static_cast<void*>(&elems_[i])) T(value);
+    }
+
+    void init0(T&& value) { init(0, std::move(value)); }
+    void init0(const T& value) { init(0, value); }
+
+    void drop(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::drop index out of bounds");
+        }
+        if (!alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::drop on dead slot");
+        }
+        alive_.reset(i);
+#endif
+        elems_[i].~T();
+    }
+
+    void drop0() { drop(0); }
+
+    T& load(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::load index out of bounds");
+        }
+        if (!alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::load on dead slot");
+        }
+#endif
+        return elems_[i];
+    }
+
+    const T& load(uint32_t i) const {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::load index out of bounds");
+        }
+        if (!alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::load on dead slot");
+        }
+#endif
+        return elems_[i];
+    }
+
+    T& load0() { return load(0); }
+    const T& load0() const { return load(0); }
+
+    T take(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= N) {
+            tpy_panic("UninitArrayStorage::take index out of bounds");
+        }
+        if (!alive_.test(i)) {
+            tpy_panic("UninitArrayStorage::take on dead slot");
+        }
+        alive_.reset(i);
+#endif
+        T result = std::move(elems_[i]);
+        elems_[i].~T();
+        return result;
+    }
+
+    T take0() { return take(0); }
+
+    T* ptr() { return elems_; }
+    const T* ptr() const { return elems_; }
+
+    static constexpr uint32_t capacity() { return static_cast<uint32_t>(N); }
+
+    void init_from_span(uint32_t start, std::span<const T> src) {
+#ifndef NDEBUG
+        if (start + src.size() > N) {
+            tpy_panic("UninitArrayStorage::init_from_span: span exceeds capacity");
+        }
+        for (std::size_t i = 0; i < src.size(); ++i) {
+            if (alive_.test(start + i)) {
+                tpy_panic("UninitArrayStorage::init_from_span on already-alive slot");
+            }
+            alive_.set(start + i);
+        }
+#endif
+        if constexpr (std::is_trivially_copyable_v<T>) {
+            std::memcpy(static_cast<void*>(&elems_[start]), src.data(), src.size() * sizeof(T));
+        } else {
+            for (std::size_t i = 0; i < src.size(); ++i) {
+                ::new (static_cast<void*>(&elems_[start + i])) T(src[i]);
+            }
+        }
+    }
+
+    void drop_n(uint32_t start, uint32_t count) {
+#ifndef NDEBUG
+        for (uint32_t i = 0; i < count; ++i) {
+            uint32_t idx = start + i;
+            if (idx >= N) {
+                tpy_panic("UninitArrayStorage::drop_n index out of bounds");
+            }
+            if (!alive_.test(idx)) {
+                tpy_panic("UninitArrayStorage::drop_n on dead slot");
+            }
+            alive_.reset(idx);
+        }
+#endif
+        if constexpr (!std::is_trivially_destructible_v<T>) {
+            for (uint32_t i = 0; i < count; ++i) {
+                elems_[start + i].~T();
+            }
+        }
+    }
+
+    void shift(uint32_t src, uint32_t dst, uint32_t count) {
+        if (count == 0 || src == dst) return;
+#ifndef NDEBUG
+        for (uint32_t i = 0; i < count; ++i) {
+            if (src + i >= N || dst + i >= N) {
+                tpy_panic("UninitArrayStorage::shift index out of bounds");
+            }
+            if (!alive_.test(src + i)) {
+                tpy_panic("UninitArrayStorage::shift on dead source slot");
+            }
+        }
+        for (uint32_t i = 0; i < count; ++i) {
+            alive_.reset(src + i);
+        }
+        for (uint32_t i = 0; i < count; ++i) {
+            alive_.set(dst + i);
+        }
+#endif
+        if constexpr (std::is_trivially_copyable_v<T>) {
+            std::memmove(static_cast<void*>(&elems_[dst]),
+                         static_cast<const void*>(&elems_[src]),
+                         static_cast<std::size_t>(count) * sizeof(T));
+        } else if (dst < src) {
+            for (uint32_t i = 0; i < count; ++i) {
+                ::new (static_cast<void*>(&elems_[dst + i]))
+                    T(std::move(elems_[src + i]));
+                elems_[src + i].~T();
+            }
+        } else {
+            for (uint32_t i = count; i > 0; --i) {
+                uint32_t idx = i - 1;
+                ::new (static_cast<void*>(&elems_[dst + idx]))
+                    T(std::move(elems_[src + idx]));
+                elems_[src + idx].~T();
+            }
+        }
+    }
+
+    // TODO: emplace(i, args...) for perfect-forwarding construction
+
+private:
+    union { T elems_[N]; };
+
+#ifndef NDEBUG
+    std::bitset<N> alive_;
+#endif
+};
+
+} // namespace tpy