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

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

@@ -0,0 +1,44 @@
+/**
+ * TurboPython Runtime - Dynamic Protocol Adapters
+ *
+ * Primary templates for Adapter<Base, T> and RefAdapter<Base, T>.
+ * Each @dynamic protocol generates partial specializations with
+ * virtual method overrides in the module's generated code.
+ */
+
+#pragma once
+
+namespace tpy {
+
+template<typename Base, typename T>
+struct Adapter;
+
+template<typename Base, typename T>
+struct RefAdapter;
+
+// Narrowing cast for `isinstance` against a STRUCTURAL conformer of a @dynamic
+// protocol. A structural `Cat` behind a `Pet*` is physically an
+// `Adapter<Pet, Cat>` (owning, from an rvalue source) or a
+// `RefAdapter<Pet, Cat>` (from an lvalue source) -- never a `Cat` that IS-A
+// `Pet` -- so `dynamic_cast<Cat*>` would always fail. Try both adapter shapes
+// and project the contained `.inner`. Returns nullptr when neither matches
+// (the object behind the pointer is a different conformer, or null).
+template<typename Base, typename T>
+T* dyn_adapter_cast(Base* p) {
+    if (auto* a = dynamic_cast<Adapter<Base, T>*>(p)) return &a->inner;
+    if (auto* r = dynamic_cast<RefAdapter<Base, T>*>(p)) return &r->inner;
+    return nullptr;
+}
+
+template<typename Base, typename T>
+const T* dyn_adapter_cast(const Base* p) {
+    if (auto* a = dynamic_cast<const Adapter<Base, T>*>(p)) return &a->inner;
+    // RefAdapter's `T& inner` is a reference member: it is not const-propagated
+    // through a const adapter, so const-qualify explicitly to honor the
+    // const-input overload's `const T*` contract.
+    if (auto* r = dynamic_cast<const RefAdapter<Base, T>*>(p))
+        return &static_cast<const T&>(r->inner);
+    return nullptr;
+}
+
+} // namespace tpy

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

@@ -0,0 +1,40 @@
+/**
+ * TurboPython Runtime - Enum Utilities
+ *
+ * Primary template for EnumUtil<T>. Each TurboPython enum generates
+ * an explicit specialization with name(), members, from_value(), and
+ * try_parse() in the module's generated code.
+ */
+
+#pragma once
+
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace tpy {
+
+template<typename T>
+struct EnumUtil;
+
+namespace detail {
+
+// Single home for the "TypeName.MEMBER" enum formatting used by
+// __repr__/__str__ (in dunder.hpp) and print_optional_val (in format.hpp).
+// `requires` is matched by the same constraint shape used at each call
+// site, so partial-template ambiguities don't arise.
+template<typename T>
+    requires std::is_enum_v<T> && requires(T x) { ::tpy::EnumUtil<T>::name(x); }
+inline std::ostream& write_enum_repr(std::ostream& os, T x) {
+    return os << ::tpy::EnumUtil<T>::type_name << "." << ::tpy::EnumUtil<T>::name(x);
+}
+
+template<typename T>
+    requires std::is_enum_v<T> && requires(T x) { ::tpy::EnumUtil<T>::name(x); }
+inline std::string enum_repr_string(T x) {
+    return std::string(::tpy::EnumUtil<T>::type_name) + "." +
+           std::string(::tpy::EnumUtil<T>::name(x));
+}
+
+} // namespace detail
+} // namespace tpy

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

@@ -0,0 +1,245 @@
+/**
+ * TurboPython Runtime - File I/O
+ *
+ * TextFile: text-mode file wrapper for the open() builtin.
+ * Supports read/write/append modes, readline, readlines,
+ * and context manager protocol (__enter__/__exit__).
+ */
+
+#pragma once
+
+#include "core.hpp"
+
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace tpy {
+
+struct FileFlags {
+    std::ios_base::openmode mode;
+    bool readable;
+    bool writable;
+
+    static const FileFlags text_read;
+    static const FileFlags binary_read;
+
+    static FileFlags parse_text(std::string_view mode) {
+        if (mode == "r" || mode == "rt")
+            return {std::ios::in, true, false};
+        if (mode == "w" || mode == "wt")
+            return {std::ios::out | std::ios::trunc, false, true};
+        if (mode == "a" || mode == "at")
+            return {std::ios::out | std::ios::app, false, true};
+        if (mode == "r+" || mode == "r+t" || mode == "rt+")
+            return {std::ios::in | std::ios::out, true, true};
+        if (mode == "w+" || mode == "w+t" || mode == "wt+")
+            return {std::ios::in | std::ios::out | std::ios::trunc, true, true};
+        if (mode == "a+" || mode == "a+t" || mode == "at+")
+            return {std::ios::in | std::ios::out | std::ios::app, true, true};
+        if (mode == "x" || mode == "xt")
+            return {std::ios::out | std::ios::trunc | std::ios::noreplace, false, true};
+        if (mode == "x+" || mode == "x+t" || mode == "xt+")
+            return {std::ios::in | std::ios::out | std::ios::trunc | std::ios::noreplace, true, true};
+        raise_value_error("invalid mode: '{}'", mode);
+    }
+
+    static FileFlags parse_binary(std::string_view mode) {
+        std::ios_base::openmode base = std::ios::binary;
+        if (mode == "rb")
+            return {base | std::ios::in, true, false};
+        if (mode == "wb")
+            return {base | std::ios::out | std::ios::trunc, false, true};
+        if (mode == "ab")
+            return {base | std::ios::out | std::ios::app, false, true};
+        if (mode == "r+b" || mode == "rb+")
+            return {base | std::ios::in | std::ios::out, true, true};
+        if (mode == "w+b" || mode == "wb+")
+            return {base | std::ios::in | std::ios::out | std::ios::trunc, true, true};
+        if (mode == "a+b" || mode == "ab+")
+            return {base | std::ios::in | std::ios::out | std::ios::app, true, true};
+        if (mode == "xb")
+            return {base | std::ios::out | std::ios::trunc | std::ios::noreplace, false, true};
+        if (mode == "x+b" || mode == "xb+")
+            return {base | std::ios::in | std::ios::out | std::ios::trunc | std::ios::noreplace, true, true};
+        raise_value_error("invalid mode: '{}'", mode);
+    }
+};
+
+inline const FileFlags FileFlags::text_read = {std::ios::in, true, false};
+inline const FileFlags FileFlags::binary_read = {std::ios::binary | std::ios::in, true, false};
+
+class TextFile {
+    std::fstream fs_;
+    std::string path_;
+    FileFlags flags_{};
+    bool closed_ = false;
+
+public:
+    TextFile(std::string_view path, FileFlags flags) : path_(path), flags_(flags) {
+        fs_.open(path_, flags_.mode);
+        if (!fs_.is_open()) {
+            raise_file_not_found_error("open(): cannot open '{}'", path);
+        }
+    }
+
+    TextFile(TextFile&&) = default;
+    TextFile& operator=(TextFile&&) = default;
+    TextFile(const TextFile&) = delete;
+    TextFile& operator=(const TextFile&) = delete;
+
+    std::string read() {
+        if (!flags_.readable) raise_os_error("read(): file not opened for reading");
+        std::ostringstream ss;
+        ss << fs_.rdbuf();
+        return ss.str();
+    }
+
+    int32_t write(std::string_view text) {
+        if (!flags_.writable) raise_os_error("write(): file not opened for writing");
+        fs_ << text;
+        return static_cast<int32_t>(text.size());
+    }
+
+    void flush() {
+        if (!flags_.writable) raise_os_error("flush(): file not opened for writing");
+        fs_.flush();
+    }
+
+    std::ostream& sink() { return fs_; }
+
+    std::string readline() {
+        if (!flags_.readable) raise_os_error("readline(): file not opened for reading");
+        std::string line;
+        if (!std::getline(fs_, line)) {
+            return "";
+        }
+        // getline strips the newline delimiter; restore it unless we hit EOF
+        // without a trailing newline (Python compat).
+        if (!fs_.eof()) {
+            line += '\n';
+        }
+        return line;
+    }
+
+    std::vector<std::string> readlines() {
+        if (!flags_.readable) raise_os_error("readlines(): file not opened for reading");
+        std::vector<std::string> lines;
+        std::string line;
+        while (std::getline(fs_, line)) {
+            if (!fs_.eof()) line += '\n';
+            lines.push_back(std::move(line));
+        }
+        return lines;
+    }
+
+    void close() {
+        if (!closed_) {
+            fs_.close();
+            closed_ = true;
+        }
+    }
+
+    TextFile& __enter__() { return *this; }
+    void __exit__(std::monostate, const BaseException*, std::monostate) { close(); }
+
+    friend std::ostream& operator<<(std::ostream& os, const TextFile& f) {
+        return os << "<TextIO '" << f.path_ << "'>";
+    }
+
+    ~TextFile() { close(); }
+};
+
+class BinaryFile {
+    std::fstream fs_;
+    std::string path_;
+    FileFlags flags_{};
+    bool closed_ = false;
+
+public:
+    BinaryFile(std::string_view path, FileFlags flags) : path_(path), flags_(flags) {
+        fs_.open(path_, flags_.mode);
+        if (!fs_.is_open()) {
+            raise_file_not_found_error("open(): cannot open '{}'", path);
+        }
+    }
+
+    BinaryFile(BinaryFile&&) = default;
+    BinaryFile& operator=(BinaryFile&&) = default;
+    BinaryFile(const BinaryFile&) = delete;
+    BinaryFile& operator=(const BinaryFile&) = delete;
+
+    std::vector<uint8_t> read() {
+        if (!flags_.readable) raise_os_error("read(): file not opened for reading");
+        return std::vector<uint8_t>(
+            std::istreambuf_iterator<char>(fs_),
+            std::istreambuf_iterator<char>()
+        );
+    }
+
+    std::vector<uint8_t> readline() {
+        if (!flags_.readable) raise_os_error("readline(): file not opened for reading");
+        std::string line;
+        if (!std::getline(fs_, line)) {
+            return {};
+        }
+        std::vector<uint8_t> result(line.begin(), line.end());
+        if (!fs_.eof()) {
+            result.push_back('\n');
+        }
+        return result;
+    }
+
+    std::vector<std::vector<uint8_t>> readlines() {
+        if (!flags_.readable) raise_os_error("readlines(): file not opened for reading");
+        std::vector<std::vector<uint8_t>> lines;
+        std::string line;
+        while (std::getline(fs_, line)) {
+            std::vector<uint8_t> row(line.begin(), line.end());
+            if (!fs_.eof()) row.push_back('\n');
+            lines.push_back(std::move(row));
+        }
+        return lines;
+    }
+
+    int32_t write(std::span<const uint8_t> data) {
+        if (!flags_.writable) raise_os_error("write(): file not opened for writing");
+        fs_.write(reinterpret_cast<const char*>(data.data()),
+                  static_cast<std::streamsize>(data.size()));
+        return static_cast<int32_t>(data.size());
+    }
+
+    void close() {
+        if (!closed_) {
+            fs_.close();
+            closed_ = true;
+        }
+    }
+
+    BinaryFile& __enter__() { return *this; }
+    void __exit__(std::monostate, const BaseException*, std::monostate) { close(); }
+
+    friend std::ostream& operator<<(std::ostream& os, const BinaryFile& f) {
+        return os << "<BinaryIO '" << f.path_ << "'>";
+    }
+
+    ~BinaryFile() { close(); }
+};
+
+// --- Builtin open() helpers ---
+
+inline TextFile builtin_open(std::string_view path) {
+    return TextFile(path, FileFlags::text_read);
+}
+
+inline TextFile builtin_open_mode(std::string_view path, std::string_view mode) {
+    return TextFile(path, FileFlags::parse_text(mode));
+}
+
+inline BinaryFile builtin_open_binary(std::string_view path, std::string_view mode = "rb") {
+    return BinaryFile(path, FileFlags::parse_binary(mode));
+}
+
+} // namespace tpy

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

@@ -0,0 +1,317 @@
+/**
+ * TurboPython Runtime - Fixed-Width Integer Checked Arithmetic
+ *
+ * Template-based overflow-checked operations for all fixed-width integer types.
+ * Supports Int8/16/32/64 and UInt8/16/32/64 with Python semantics.
+ *
+ * The checked-arith helpers are marked constexpr so that `Final[IntN]`
+ * initializers that reference other Finals can be constant-evaluated. The
+ * overflow / divide-by-zero error branches route through non-constexpr
+ * helpers (`raise_fixedint_overflow`, `raise<ZeroDivisionError>`,
+ * `raise<ValueError>`); this is permitted under C++23 P2448 as long as those
+ * branches are not reached during constant evaluation. When they are reached
+ * (e.g. `Final[Int32] = -INT32_MIN`), the compiler rejects the call, turning
+ * a would-be runtime panic into a compile-time error.
+ */
+
+#pragma once
+
+#include <cctype>
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include "core.hpp"
+
+namespace tpy {
+
+// --- Checked power helper (reusable across all integer types) ---
+
+template<typename T>
+constexpr bool try_pow(T base, T exp, T& result) {
+    if (exp < 0) return false;
+    if (exp == 0) { result = 1; return true; }
+
+    result = 1;
+    T b = base;
+
+    while (exp > 0) {
+        if (exp & 1) {
+            if (__builtin_mul_overflow(result, b, &result)) {
+                return false;
+            }
+        }
+        exp >>= 1;
+        if (exp > 0) {
+            if (__builtin_mul_overflow(b, b, &b)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+// --- Type name helper for error messages ---
+
+template<typename T> constexpr const char* fixed_int_name() { return "FixedInt"; }
+template<> constexpr const char* fixed_int_name<int8_t>() { return "Int8"; }
+template<> constexpr const char* fixed_int_name<int16_t>() { return "Int16"; }
+template<> constexpr const char* fixed_int_name<int32_t>() { return "Int32"; }
+template<> constexpr const char* fixed_int_name<int64_t>() { return "Int64"; }
+template<> constexpr const char* fixed_int_name<uint8_t>() { return "UInt8"; }
+template<> constexpr const char* fixed_int_name<uint16_t>() { return "UInt16"; }
+template<> constexpr const char* fixed_int_name<uint32_t>() { return "UInt32"; }
+template<> constexpr const char* fixed_int_name<uint64_t>() { return "UInt64"; }
+
+// --- Checked arithmetic ---
+
+template<typename T>
+constexpr T add_check(T a, T b) {
+    T result;
+    if (__builtin_add_overflow(a, b, &result)) {
+        raise_fixedint_overflow("{} overflow in addition", fixed_int_name<T>());
+    }
+    return result;
+}
+
+template<typename T>
+constexpr T sub_check(T a, T b) {
+    T result;
+    if (__builtin_sub_overflow(a, b, &result)) {
+        raise_fixedint_overflow("{} overflow in subtraction", fixed_int_name<T>());
+    }
+    return result;
+}
+
+template<typename T>
+constexpr T mul_check(T a, T b) {
+    T result;
+    if (__builtin_mul_overflow(a, b, &result)) {
+        raise_fixedint_overflow("{} overflow in multiplication", fixed_int_name<T>());
+    }
+    return result;
+}
+
+// Python floor division: round toward negative infinity.
+// Divisor must be non-zero (caller's responsibility).
+template<typename T>
+constexpr T div_floor(T a, T b) {
+    if constexpr (std::is_signed_v<T>) {
+        if (a == std::numeric_limits<T>::min() && b == static_cast<T>(-1)) [[unlikely]] {
+            raise_fixedint_overflow("integer overflow in division");
+        }
+        T q = a / b;
+        T r = a % b;
+        if (r != 0 && ((r < 0) != (b < 0))) {
+            q -= 1;
+        }
+        return q;
+    } else {
+        return a / b;
+    }
+}
+
+// Python modulo: result has same sign as divisor.
+// Divisor must be non-zero (caller's responsibility).
+template<typename T>
+constexpr T mod_floor(T a, T b) {
+    if constexpr (std::is_signed_v<T>) {
+        if (a == std::numeric_limits<T>::min() && b == static_cast<T>(-1)) [[unlikely]] {
+            return 0;  // Python: INT_MIN % -1 == 0
+        }
+        T r = a % b;
+        if (r != 0 && ((r < 0) != (b < 0))) {
+            r += b;
+        }
+        return r;
+    } else {
+        return a % b;
+    }
+}
+
+// Checked variants: also check for division by zero.
+template<typename T>
+constexpr T div_check(T a, T b) {
+    if (b == 0) [[unlikely]] {
+        raise_zero_division_error("integer division or modulo by zero");
+    }
+    return div_floor(a, b);
+}
+
+template<typename T>
+constexpr T mod_check(T a, T b) {
+    if (b == 0) [[unlikely]] {
+        raise_zero_division_error("integer modulo by zero");
+    }
+    return mod_floor(a, b);
+}
+
+template<typename T>
+constexpr T neg_check(T a) {
+    static_assert(std::is_signed_v<T>, "Negation only supported on signed types");
+    if (a == std::numeric_limits<T>::min()) {
+        raise_fixedint_overflow("{} overflow in negation", fixed_int_name<T>());
+    }
+    return -a;
+}
+
+template<typename T>
+constexpr T lshift_check(T a, T b) {
+    if constexpr (std::is_signed_v<T>) {
+        if (b < 0) {
+            raise_value_error("negative shift count");
+        }
+    }
+    constexpr int bits = sizeof(T) * 8;
+    if (b >= static_cast<T>(bits)) {
+        raise_fixedint_overflow("{} overflow in left shift", fixed_int_name<T>());
+    }
+    using U = std::make_unsigned_t<T>;
+    T result = static_cast<T>(static_cast<U>(a) << static_cast<U>(b));
+    if ((result >> b) != a) {
+        raise_fixedint_overflow("{} overflow in left shift", fixed_int_name<T>());
+    }
+    return result;
+}
+
+template<typename T>
+constexpr T rshift_check(T a, T b) {
+    if constexpr (std::is_signed_v<T>) {
+        if (b < 0) {
+            raise_value_error("negative shift count");
+        }
+    }
+    constexpr int bits = sizeof(T) * 8;
+    if (b >= static_cast<T>(bits)) {
+        raise_fixedint_overflow("{} shift count too large", fixed_int_name<T>());
+    }
+    return a >> b;
+}
+
+template<typename T>
+constexpr T pow_check(T base, T exp) {
+    if constexpr (std::is_signed_v<T>) {
+        if (exp < 0) {
+            // TPy-specific limitation: int**neg returns float in CPython, but
+            // our static return type is T. Stays panic (not raise_fixedint_overflow)
+            // because it's a language-shape issue, not a numeric overflow -- the
+            // future fixed-int policy switch can never make this branch "none".
+            tpy_panic("Negative exponent not supported (would require float)");
+        }
+    }
+    T result;
+    if (!try_pow(base, exp, result)) {
+        raise_fixedint_overflow("{} overflow in power", fixed_int_name<T>());
+    }
+    return result;
+}
+
+// --- Checked cast between fixed-int types ---
+
+template<typename To, typename From>
+constexpr To int_cast_check(From v) {
+    if constexpr (std::is_signed_v<From> && std::is_unsigned_v<To>) {
+        if (v < 0 || static_cast<std::make_unsigned_t<From>>(v) > std::numeric_limits<To>::max()) {
+            raise_fixedint_overflow("{} overflow: value out of range", fixed_int_name<To>());
+        }
+    } else if constexpr (std::is_unsigned_v<From> && std::is_signed_v<To>) {
+        if (v > static_cast<std::make_unsigned_t<To>>(std::numeric_limits<To>::max())) {
+            raise_fixedint_overflow("{} overflow: value out of range", fixed_int_name<To>());
+        }
+    } else if constexpr (sizeof(From) > sizeof(To)) {
+        if (v < static_cast<From>(std::numeric_limits<To>::min()) ||
+            v > static_cast<From>(std::numeric_limits<To>::max())) {
+            raise_fixedint_overflow("{} overflow: value out of range", fixed_int_name<To>());
+        }
+    }
+    return static_cast<To>(v);
+}
+
+// --- Conversion from other types ---
+
+template<typename T>
+T from_float_check(double v) {
+    if (std::isnan(v)) {
+        raise_value_error("cannot convert float NaN to integer");
+    }
+    if (std::isinf(v)) {
+        raise_overflow_error("cannot convert float infinity to integer");
+    }
+    v = std::trunc(v);
+    if constexpr (sizeof(T) <= 4) {
+        // double represents all <=32-bit integer values exactly
+        constexpr auto lo = static_cast<double>(std::numeric_limits<T>::min());
+        constexpr auto hi = static_cast<double>(std::numeric_limits<T>::max());
+        if (v < lo || v > hi) {
+            raise_fixedint_overflow("{} overflow: float value out of range",
+                                    fixed_int_name<T>());
+        }
+    } else if constexpr (std::is_signed_v<T>) {
+        // int64_t range [-2^63, 2^63-1]: use exact power-of-2 bounds
+        // to avoid static_cast<double>(max) rounding up past the true max
+        constexpr double lo = -9223372036854775808.0;  // -2^63, exact
+        constexpr double hi = 9223372036854775808.0;   //  2^63, exact
+        if (v < lo || v >= hi) {
+            raise_fixedint_overflow("{} overflow: float value out of range",
+                                    fixed_int_name<T>());
+        }
+    } else {
+        // uint64_t range [0, 2^64-1]: 2^64 is exact in double
+        constexpr double hi = 18446744073709551616.0;  // 2^64, exact
+        if (v < 0.0 || v >= hi) {
+            raise_fixedint_overflow("{} overflow: float value out of range",
+                                    fixed_int_name<T>());
+        }
+    }
+    return static_cast<T>(v);
+}
+
+template<typename T>
+T from_str_check(std::string_view s) {
+    size_t start = 0;
+    while (start < s.size() && std::isspace(static_cast<unsigned char>(s[start]))) ++start;
+    size_t end = s.size();
+    while (end > start && std::isspace(static_cast<unsigned char>(s[end - 1]))) --end;
+
+    auto type_name = fixed_int_name<T>();
+
+    if (start >= end) {
+        raise_value_error("invalid literal for {}() with base 10: '{}'", type_name, s);
+    }
+
+    std::string trimmed(s.substr(start, end - start));
+    char* endptr;
+    errno = 0;
+
+    if constexpr (std::is_signed_v<T>) {
+        long long result = std::strtoll(trimmed.c_str(), &endptr, 10);
+        if (endptr != trimmed.c_str() + trimmed.size()) {
+            raise_value_error("invalid literal for {}() with base 10: '{}'", type_name, s);
+        }
+        if (errno == ERANGE || result < static_cast<long long>(std::numeric_limits<T>::min())
+                            || result > static_cast<long long>(std::numeric_limits<T>::max())) {
+            raise_fixedint_overflow("{} overflow: value out of range for '{}'", type_name, s);
+        }
+        return static_cast<T>(result);
+    } else {
+        // Check for negative sign on unsigned types
+        if (trimmed[0] == '-') {
+            raise_fixedint_overflow("{} overflow: negative value for unsigned type '{}'",
+                                    type_name, s);
+        }
+        unsigned long long result = std::strtoull(trimmed.c_str(), &endptr, 10);
+        if (endptr != trimmed.c_str() + trimmed.size()) {
+            raise_value_error("invalid literal for {}() with base 10: '{}'", type_name, s);
+        }
+        if (errno == ERANGE || result > static_cast<unsigned long long>(std::numeric_limits<T>::max())) {
+            raise_fixedint_overflow("{} overflow: value out of range for '{}'", type_name, s);
+        }
+        return static_cast<T>(result);
+    }
+}
+
+} // namespace tpy