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

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

@@ -0,0 +1,461 @@
+/**
+ * TurboPython Runtime - Any (typing.Any)
+ *
+ * Type-erased value cell. Holds any concrete copyable value via std::any
+ * plus a per-type ops table for the universal operations (print, str,
+ * repr, bool, equals, hash) that the compiler dispatches on raw `Any`.
+ *
+ * v1 stores copyable contents only -- the std::any backing requires
+ * CopyConstructible. Move-only support is deferred (would require a
+ * custom wrapper with destroy/move slots replacing std::any).
+ *
+ * See docs/ANY_TYPE_DESIGN.md for the full design.
+ *
+ * Depends on: dunder.hpp (__str__, __repr__, __hash__), builtins.hpp
+ * (to_bool), core.hpp (raise<E>, tpy_panic, demangle_type_name),
+ * type_name.hpp (user-facing TPy type names).
+ */
+
+#pragma once
+
+#include <any>
+#include <concepts>
+#include <cstdint>
+#include <format>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+namespace tpy {
+
+// Forward declarations from other tpy headers; these resolve via ADL when
+// any.hpp is included after dunder.hpp / builtins.hpp / core.hpp via the
+// umbrella tpy.hpp. We do not include them directly to keep this header
+// self-contained when read in isolation.
+
+struct AnyOps;
+
+// ---------------------------------------------------------------------
+// Any: std::any storage + per-type ops table
+// ---------------------------------------------------------------------
+
+struct Any {
+    std::any value;
+    const AnyOps* ops;
+
+    // Default-constructed Any is the empty/moved-from state. TPy source
+    // does not allow this (no default-init for non-trivial types); it
+    // arises only from std::any moves. Operations on an empty Any panic
+    // -- see any_cast_or_panic / any_eq / any_hash below.
+    Any() noexcept : value(), ops(nullptr) {}
+
+    Any(std::any v, const AnyOps* o) noexcept
+        : value(std::move(v)), ops(o) {}
+
+    bool empty() const noexcept { return !value.has_value(); }
+};
+
+// ---------------------------------------------------------------------
+// AnyOps: dispatch table for universal operations
+// ---------------------------------------------------------------------
+//
+// `equals` and `hash` are populated only for types that satisfy the
+// corresponding compile-time concept (operator== / tpy::__hash__). When
+// null, the runtime path panics or returns False per the design doc.
+
+struct AnyOps {
+    void (*print)(std::ostream&, const std::any&);
+    void (*str)(std::string&, const std::any&);
+    void (*repr)(std::string&, const std::any&);
+    bool (*to_bool)(const std::any&);
+    bool (*equals)(const std::any&, const std::any&);   // null if T not Eq
+    std::uint64_t (*hash)(const std::any&);             // null if T not Hashable
+    // User-facing TPy type name of the cell's T (e.g. "int", "str",
+    // "module.MyClass"). Cold-path; only consulted by panic messages.
+    std::string (*type_name)();
+};
+
+// ---------------------------------------------------------------------
+// Per-T conditional slot generation
+// ---------------------------------------------------------------------
+
+namespace detail {
+
+template <typename T>
+concept any_str_capable = requires(const T& t) {
+    { ::tpy::__str__(t) } -> std::convertible_to<std::string>;
+};
+
+// The concept stays on `::tpy::__repr__` rather than `::tpy::repr_of`
+// because repr_of is a single template that always SFINAE-passes here
+// (then hard-errors inside), so it can't act as a capability check.
+// `::tpy::__repr__(t)` resolves against the explicit overload set: if no
+// matching __repr__ exists for T (e.g. raw containers like
+// std::vector<T>, ordered_set<T> -- they print via *Printer wrappers,
+// not free __repr__), the requires-clause cleanly fails and the slot
+// falls back to __str__/typeid. The actual call site uses repr_of so
+// ADL into a user record's namespace still picks up per-record default
+// overrides.
+template <typename T>
+concept any_repr_capable = requires(const T& t) {
+    { ::tpy::__repr__(t) } -> std::convertible_to<std::string>;
+};
+
+// Mirror tpy::to_bool's acceptance criteria. Going through `tpy::to_bool`
+// itself would instantiate its `static_assert(false, ...)` for
+// non-capable T at concept-check time and break compilation.
+template <typename T>
+concept any_to_bool_capable =
+    std::is_same_v<T, std::monostate> ||
+    std::is_constructible_v<bool, T> ||
+    requires(const T& t) { { t.empty() } -> std::convertible_to<bool>; } ||
+    requires(const T& t) { { t.__bool__() } -> std::convertible_to<bool>; };
+
+template <typename T>
+concept any_eq_capable = requires(const T& a, const T& b) {
+    { a == b } -> std::convertible_to<bool>;
+};
+
+template <typename T>
+concept any_hash_capable = requires(const T& t) {
+    { ::tpy::__hash__(t) } -> std::convertible_to<std::uint64_t>;
+};
+
+// Mangled typeid name as the fallback for types without __str__/__repr__.
+// Python's default is `<ClassName object at 0x...>`; TPy has no class-name
+// registry, so the typeid's mangled name is the best we can do.
+inline std::string fallback_object_repr(const std::any& a) {
+    std::string s = "<";
+    s += a.type().name();
+    s += " object>";
+    return s;
+}
+
+// Resolve the per-T value of type T from std::any once, then pick a
+// rendering: prefer_repr=false favours __str__ over __repr__ (str/print
+// slots); prefer_repr=true inverts (repr slot). Sink can be either
+// std::string& (append) or std::ostream& (operator<<); _emit_to is
+// overloaded for both.
+inline void _emit_to(std::string& buf, std::string_view s) { buf.append(s); }
+inline void _emit_to(std::ostream& os, std::string_view s) { os << s; }
+
+template <typename T, bool prefer_repr, typename Sink>
+inline void _write_str_or_repr(Sink& sink, const std::any& a) {
+    if constexpr (prefer_repr) {
+        if constexpr (any_repr_capable<T>) {
+            _emit_to(sink, ::tpy::repr_of(std::any_cast<const T&>(a)));
+            return;
+        } else if constexpr (any_str_capable<T>) {
+            _emit_to(sink, ::tpy::__str__(std::any_cast<const T&>(a)));
+            return;
+        }
+    } else {
+        if constexpr (any_str_capable<T>) {
+            _emit_to(sink, ::tpy::__str__(std::any_cast<const T&>(a)));
+            return;
+        } else if constexpr (any_repr_capable<T>) {
+            _emit_to(sink, ::tpy::repr_of(std::any_cast<const T&>(a)));
+            return;
+        }
+    }
+    _emit_to(sink, fallback_object_repr(a));
+}
+
+template <typename T>
+constexpr void (*str_slot_for() noexcept)(std::string&, const std::any&) {
+    return +[](std::string& buf, const std::any& a) {
+        _write_str_or_repr<T, /*prefer_repr=*/false>(buf, a);
+    };
+}
+
+template <typename T>
+constexpr void (*print_slot_for() noexcept)(std::ostream&, const std::any&) {
+    return +[](std::ostream& os, const std::any& a) {
+        _write_str_or_repr<T, /*prefer_repr=*/false>(os, a);
+    };
+}
+
+template <typename T>
+constexpr void (*repr_slot_for() noexcept)(std::string&, const std::any&) {
+    return +[](std::string& buf, const std::any& a) {
+        _write_str_or_repr<T, /*prefer_repr=*/true>(buf, a);
+    };
+}
+
+template <typename T>
+constexpr bool (*to_bool_slot_for() noexcept)(const std::any&) {
+    if constexpr (any_to_bool_capable<T>) {
+        return +[](const std::any& a) -> bool {
+            return ::tpy::to_bool(std::any_cast<const T&>(a));
+        };
+    } else {
+        // Python default: objects without __bool__/__len__ are truthy.
+        return +[](const std::any&) -> bool { return true; };
+    }
+}
+
+template <typename T>
+constexpr bool (*equals_slot_for() noexcept)(const std::any&, const std::any&) {
+    if constexpr (any_eq_capable<T>) {
+        return +[](const std::any& a, const std::any& b) -> bool {
+            return std::any_cast<const T&>(a) == std::any_cast<const T&>(b);
+        };
+    } else {
+        return nullptr;
+    }
+}
+
+template <typename T>
+constexpr std::uint64_t (*hash_slot_for() noexcept)(const std::any&) {
+    if constexpr (any_hash_capable<T>) {
+        return +[](const std::any& a) -> std::uint64_t {
+            return ::tpy::__hash__(std::any_cast<const T&>(a));
+        };
+    } else {
+        return nullptr;
+    }
+}
+
+template <typename T>
+constexpr std::string (*type_name_slot_for() noexcept)() {
+    return +[]() -> std::string { return ::tpy::type_name<T>(); };
+}
+
+}  // namespace detail
+
+// `inline constexpr` template variables guarantee a single instance per
+// T across translation units in a single binary. Cross-shared-library
+// identity is out of scope (TPy builds as one binary).
+//
+// Every slot is conditionally generated. Slots whose underlying op is
+// missing fall back to a sensible default (Python-conformant where
+// possible): str/print/repr render `<typeid object>`, to_bool returns
+// true, equals/hash stay null and trigger the documented runtime
+// behaviour (== returns False; hash() panics).
+template <typename T>
+inline constexpr AnyOps any_ops_for = {
+    /*print=*/detail::print_slot_for<T>(),
+    /*str=*/detail::str_slot_for<T>(),
+    /*repr=*/detail::repr_slot_for<T>(),
+    /*to_bool=*/detail::to_bool_slot_for<T>(),
+    /*equals=*/detail::equals_slot_for<T>(),
+    /*hash=*/detail::hash_slot_for<T>(),
+    /*type_name=*/detail::type_name_slot_for<T>(),
+};
+
+// ---------------------------------------------------------------------
+// make_any<T>: factory that wires the value to its per-T ops table
+// ---------------------------------------------------------------------
+//
+// Codegen emits `::tpy::make_any(value)` and lets argument deduction
+// pick T -- so the source is `make_any(BigInt(42))` rather than the
+// hand-spelled `Any{std::any{BigInt(42)}, &any_ops_for<BigInt>}`.
+// Callers must build `value` so its decayed C++ type *is* the desired
+// storage typeid (e.g. `BigInt(42)` not `42`, `std::string("hi")` not
+// `"hi"`); the codegen layer's _any_storage_form ensures that.
+
+template <typename T>
+inline Any make_any(T value) {
+    return Any{std::any{std::move(value)}, &any_ops_for<T>};
+}
+
+// ---------------------------------------------------------------------
+// any_cast_or_panic<T>: checked extraction
+// ---------------------------------------------------------------------
+//
+// const-ref overload copies the contents out (auto-coerce paths use
+// this). The rvalue overload moves out at last use.
+
+namespace detail {
+
+template <typename T>
+inline void check_any_cast(const Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    if (a.value.type() != typeid(T)) {
+        ::tpy::raise_type_error("Any holds {}, cannot cast to {}",
+                                a.ops->type_name(),
+                                ::tpy::type_name<T>());
+    }
+}
+
+}  // namespace detail
+
+template <typename T>
+T any_cast_or_panic(const Any& a) {
+    detail::check_any_cast<T>(a);
+    return std::any_cast<T>(a.value);
+}
+
+template <typename T>
+T any_cast_or_panic(Any&& a) {
+    detail::check_any_cast<T>(a);
+    T moved = std::any_cast<T>(std::move(a.value));
+    // Clear the source so the documented "use of empty/moved-from Any"
+    // panic fires on subsequent access. std::any_cast<T>(rvalue) does
+    // not necessarily empty the source.
+    a.value.reset();
+    a.ops = nullptr;
+    return moved;
+}
+
+// ---------------------------------------------------------------------
+// any_eq / any_eq_concrete / any_hash
+// ---------------------------------------------------------------------
+//
+// `==` semantics: type-mismatch returns False (Python behaviour for
+// non-promotable types). When the equals slot is null (T isn't Eq),
+// also False -- the only honest answer when T has no notion of equality.
+// Empty/moved-from Any is never equal to anything (also returns False).
+
+inline bool any_eq(const Any& a, const Any& b) {
+    if (a.empty() || b.empty()) return false;
+    if (a.value.type() != b.value.type()) return false;
+    if (a.ops == nullptr || a.ops->equals == nullptr) return false;
+    return a.ops->equals(a.value, b.value);
+}
+
+template <typename U>
+bool any_eq_concrete(const Any& a, const U& b) {
+    if (a.empty()) return false;
+    if (a.value.type() != typeid(U)) return false;
+    return std::any_cast<const U&>(a.value) == b;
+}
+
+template <typename U>
+bool any_eq_concrete(const U& a, const Any& b) {
+    return any_eq_concrete<U>(b, a);
+}
+
+// Hashing: panics if the contained T is not Hashable, or if the cell
+// is empty. Compile-time `hash(any_var)` cannot fail at type check
+// because Any satisfies the Hashable concept at the type-system level
+// -- the runtime check is the trade-off for accepting arbitrary T.
+inline std::uint64_t any_hash(const Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    if (a.ops == nullptr || a.ops->hash == nullptr) {
+        std::string name = (a.ops != nullptr)
+            ? a.ops->type_name()
+            : ::tpy::demangle_type_name(a.value.type().name());
+        ::tpy::raise_type_error("unhashable type: '{}'", name);
+    }
+    return a.ops->hash(a.value);
+}
+
+// Container-element printing routes through `tpy::detail::print_element`,
+// which renders strings as `'foo'` (repr-flavoured) so `print(d)` for
+// `dict[str, str]` reads `{'k': 'v'}`. Any values inside containers
+// follow the same convention -- route through the repr slot rather
+// than the str slot used by top-level operator<<.
+namespace detail {
+inline void print_element(std::ostream& os, const ::tpy::Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    std::string buf;
+    a.ops->repr(buf, a.value);
+    os << buf;
+}
+}  // namespace detail
+
+// ---------------------------------------------------------------------
+// Integration with TPy runtime primitives
+// ---------------------------------------------------------------------
+//
+// `__str__(Any)` falls through to `operator<<` via dunder.hpp's
+// generic-fallback chain -- defining `operator<<` is enough.
+// `__repr__(Any)` needs an explicit definition because the fallback
+// would route through `operator<<` (which renders via the str slot,
+// not the repr slot) and silently produce the str representation.
+
+inline std::ostream& operator<<(std::ostream& os, const Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    a.ops->print(os, a.value);
+    return os;
+}
+
+inline std::string __repr__(const Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    std::string buf;
+    a.ops->repr(buf, a.value);
+    return buf;
+}
+
+inline std::uint64_t __hash__(const Any& a) {
+    return any_hash(a);
+}
+
+// `to_bool(const T&)` in builtins.hpp tests `requires { x.empty(); }`
+// before `__bool__()`, so Any's empty() helper would otherwise hijack
+// truthiness. This explicit overload routes through the to_bool slot.
+inline bool to_bool(const Any& a) {
+    if (a.empty()) {
+        ::tpy::tpy_panic("use of empty/moved-from Any");
+    }
+    return a.ops->to_bool(a.value);
+}
+
+// Equality: typeid-checked. Type mismatch returns False (Python
+// behaviour for incomparable types); null equals slot also False.
+
+inline bool operator==(const Any& a, const Any& b) {
+    return any_eq(a, b);
+}
+
+template <typename U>
+    requires (!std::same_as<U, Any>)
+inline bool operator==(const Any& a, const U& b) {
+    return any_eq_concrete<U>(a, b);
+}
+
+template <typename U>
+    requires (!std::same_as<U, Any>)
+inline bool operator==(const U& a, const Any& b) {
+    return any_eq_concrete<U>(b, a);
+}
+
+}  // namespace tpy
+
+// std::hash<tpy::Any> for use as a key in std::unordered_map / set
+// based containers (TPy's ordered_map / ordered_set). Routes through
+// the per-type hash slot; panics if the contained T isn't Hashable.
+template <>
+struct std::hash<::tpy::Any> {
+    std::size_t operator()(const ::tpy::Any& a) const {
+        return static_cast<std::size_t>(::tpy::any_hash(a));
+    }
+};
+
+// std::format / f-string support: route through the str slot. Format
+// specs are not currently supported on Any (the design defers richer
+// dispatch); only `{}` is accepted.
+template <>
+struct std::formatter<::tpy::Any> {
+    constexpr auto parse(std::format_parse_context& ctx) {
+        auto it = ctx.begin();
+        if (it != ctx.end() && *it != '}') {
+            throw std::format_error(
+                "format specs on Any are not supported -- narrow first");
+        }
+        return it;
+    }
+
+    auto format(const ::tpy::Any& a, std::format_context& ctx) const {
+        if (a.empty()) {
+            ::tpy::tpy_panic("use of empty/moved-from Any");
+        }
+        std::string buf;
+        a.ops->str(buf, a.value);
+        return std::format_to(ctx.out(), "{}", buf);
+    }
+};

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

@@ -0,0 +1,117 @@
+/**
+ * TurboPython Runtime - Output sink dispatch
+ *
+ * Resolves a print()-style file= target to a std::ostream& usable with
+ * the existing operator<< chain. Three concrete overloads bypass any
+ * adapter (cout/cerr via std::ostream&, sys.stdout/stderr via StdStream,
+ * open()-files via TextFile); a fallback template wraps any user type
+ * satisfying the Writable concept in a streambuf adapter.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <ostream>
+#include <streambuf>
+#include <string_view>
+#include <type_traits>
+
+#include "file.hpp"
+#include "system.hpp"
+
+namespace tpy {
+
+template <typename W>
+concept WritableSink = requires(W& w, std::string_view sv) {
+    { w.write(sv) } -> std::convertible_to<int32_t>;
+    { w.flush() } -> std::same_as<void>;
+};
+
+namespace detail {
+
+// Buffered streambuf forwarding to a Writable's write() / flush().
+// sync() drains the buffer AND calls W::flush() (semantics for `<< std::flush`);
+// the destructor only drains, matching std::ostream's no-flush-on-destroy.
+template <typename W>
+class WritableStreambuf final : public std::streambuf {
+    W* w_;
+    static constexpr std::size_t kBufSize = 256;
+    char buf_[kBufSize];
+
+    void drain() {
+        const auto n = pptr() - pbase();
+        if (n > 0) {
+            w_->write(std::string_view(pbase(), static_cast<std::size_t>(n)));
+            setp(buf_, buf_ + kBufSize);
+        }
+    }
+
+protected:
+    std::streamsize xsputn(const char* s, std::streamsize n) override {
+        if (n <= 0) return 0;
+        if (pptr() != pbase()) drain();
+        // Mirrors Python's io.IOBase.write: short-write / error returns from
+        // the user's write() are not propagated as a streambuf failure.
+        w_->write(std::string_view(s, static_cast<std::size_t>(n)));
+        return n;
+    }
+
+    int_type overflow(int_type ch) override {
+        drain();
+        if (!traits_type::eq_int_type(ch, traits_type::eof())) {
+            *pptr() = traits_type::to_char_type(ch);
+            pbump(1);
+        }
+        return traits_type::not_eof(ch);
+    }
+
+    int sync() override {
+        drain();
+        w_->flush();
+        return 0;
+    }
+
+public:
+    explicit WritableStreambuf(W& w) : w_(&w) {
+        setp(buf_, buf_ + kBufSize);
+    }
+
+    ~WritableStreambuf() override { drain(); }
+
+    WritableStreambuf(const WritableStreambuf&) = delete;
+    WritableStreambuf(WritableStreambuf&&) = delete;
+    WritableStreambuf& operator=(const WritableStreambuf&) = delete;
+    WritableStreambuf& operator=(WritableStreambuf&&) = delete;
+};
+
+template <typename W>
+class WritableOstream final : public std::ostream {
+    WritableStreambuf<W> sb_;
+
+public:
+    explicit WritableOstream(W& w) : std::ostream(nullptr), sb_(w) {
+        rdbuf(&sb_);
+    }
+
+    WritableOstream(const WritableOstream&) = delete;
+    WritableOstream(WritableOstream&&) = delete;
+    WritableOstream& operator=(const WritableOstream&) = delete;
+    WritableOstream& operator=(WritableOstream&&) = delete;
+};
+
+} // namespace detail
+
+inline std::ostream& as_ostream(std::ostream& os) { return os; }
+inline std::ostream& as_ostream(StdStream& s)    { return s.sink(); }
+inline std::ostream& as_ostream(TextFile& f)     { return f.sink(); }
+
+template <typename W>
+    requires WritableSink<W>
+          && (!std::is_base_of_v<std::ostream, W>)
+          && (!std::is_same_v<std::remove_cv_t<W>, StdStream>)
+          && (!std::is_same_v<std::remove_cv_t<W>, TextFile>)
+detail::WritableOstream<W> as_ostream(W& w) {
+    return detail::WritableOstream<W>(w);
+}
+
+} // namespace tpy

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

@@ -0,0 +1,76 @@
+/**
+ * TurboPython Runtime - Async primitives
+ *
+ * The async surface lives in TPy; see `lib/tpy/tpy/coro/__init__.py`
+ * (Waker, Awaker) and `lib/tpy/asyncio/_executor.py` (Executor,
+ * _ExecutorScope, _current_executor). The C++ side carries two pieces:
+ * `CancelledError` (thrown into a coroutine at the resumed-await
+ * position when its task is cancelled) and `poll_with_cancel`, the
+ * resume-case helper template every async-def coro frame uses to
+ * propagate outer cancellation through to the in-flight sub-coro
+ * before polling.
+ */
+
+#pragma once
+
+#include "core.hpp"
+
+namespace tpy {
+
+/**
+ * CancelledError -- thrown into a coroutine at the resumed-await position
+ * when its task is cancelled. Inherits BaseException (not Exception) so
+ * `except Exception:` does not silently swallow it.
+ */
+struct CancelledError : BaseException {
+    CancelledError() : BaseException("CancelledError") {}
+    using BaseException::BaseException;
+    TPY_THROWABLE_VIRTUALS(CancelledError)
+};
+
+/**
+ * Resume-case helper: poll an async-def frame's sub-coroutine while
+ * propagating outer cancellation through to it.
+ *
+ * Called from every `S_AFTER_AWAIT_N` block emitted by the async-def
+ * codegen. If the outer's `__cancel_pending` flag is set on entry,
+ * the helper delivers the cancel by clearing the flag, calling
+ * `sub->cancel()`, then polling -- so the sub observes the cancel at
+ * its own next suspension point and can run `finally`-with-await
+ * cleanup. Three completion paths:
+ *
+ *  - Sub returns Pending and cancel was being delivered: re-set the
+ *    outer's flag so the cancel persists until the next poll attempt
+ *    actually delivers it.
+ *  - Sub raises (CancelledError or another exception): unwinds with
+ *    a clean cancel_pending state -- nested `finally`-with-await
+ *    bodies in the outer don't get re-cancelled at every new
+ *    suspension.
+ *  - Sub returns Ready synchronously while we were delivering cancel:
+ *    the sub raced past the cancel signal. Outer cancel still wins;
+ *    throw `CancelledError`. (The sub's Ready value is discarded as
+ *    the returned Poll's storage unwinds.)
+ *
+ * `Sub` is duck-typed: an `std::optional<T>` or `T*` whose pointee
+ * provides `cancel()` and `__poll__(Waker) -> Poll<T>`. Both shapes
+ * use `->`, so the same template body works for INLINE/ERASED and
+ * BORROWED await modes. Inline so the compiler can fold the
+ * not-cancelling fast path back to a plain `sub->__poll__(waker)`.
+ */
+template <typename Sub, typename W>
+inline auto poll_with_cancel(Sub&& sub, bool& cancel_pending, W&& waker) {
+    bool was_canceling = cancel_pending;
+    if (was_canceling) {
+        cancel_pending = false;
+        sub->cancel();
+    }
+    auto r = sub->__poll__(waker);
+    if (r.is_pending()) {
+        if (was_canceling) cancel_pending = true;
+        return r;
+    }
+    if (was_canceling) throw CancelledError();
+    return r;
+}
+
+}  // namespace tpy