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

tpyc/_data/lib/tpy/_bindings/pcre2.py

@@ -0,0 +1,173 @@
+# tpy: cpp_namespace("tpystd::_bindings::pcre2")
+# tpy: include("<tpy/stdlib/pcre2_h.hpp>")
+# tpy: link("pcre2", managed=True)
+"""Raw PCRE2 C bindings.
+
+One @native declaration per pcre2_*_8 primitive, matching the upstream C
+ABI 1:1. No Python semantics.
+Consumers (the public `re` facade) build user-visible Pattern / Match
+classes on top of these raw handles, using __del__ for RAII over the
+opaque pcre2_code* / pcre2_match_data* lifetimes.
+
+Naming:
+  - Opaque type markers: `Code`, `MatchData`, `MatchContext`. The TPy-level
+    handle is `Ptr[Code]` etc., which codegens to `pcre2_code_8*`.
+  - All function names mirror the PCRE2 C names with the `_8` suffix dropped.
+
+Constants are hardcoded UInt32 values matching pcre2.h. PCRE2's flag values
+are part of its public ABI and don't change between versions.
+"""
+
+from typing import Final
+from tpy import Ptr, UInt8, UInt32, UInt64, Int32, readonly
+from tpy.extern import native
+
+
+# ---------- Opaque type markers ----------
+# Never instantiated directly; only passed/returned as `Ptr[X]`. The empty
+# native class binds the C struct name so `Ptr[Code]` becomes `pcre2_code_8*`
+# -- declared as a global-scope forward struct + alias in
+# `runtime/cpp/include/tpy/stdlib/pcre2_h.hpp` (matches upstream pcre2.h
+# layout; the real struct definitions live in PCRE2's own .c files).
+
+@native("::pcre2_code_8")
+class Code: ...
+
+@native("::pcre2_match_data_8")
+class MatchData: ...
+
+@native("::pcre2_match_context_8")
+class MatchContext: ...
+
+# Context types we never construct -- passed as bare `Ptr[...]` to the
+# PCRE2 functions that accept an optional context override. Caller always
+# passes `None` (= default contexts; `Ptr[T]` is already nullable).
+@native("::pcre2_compile_context_8")
+class CompileContext: ...
+
+@native("::pcre2_general_context_8")
+class GeneralContext: ...
+
+
+# ---------- Compile / match flags (subset we actually use) ----------
+# Names mirror upstream pcre2.h exactly. Safe because pcre2.h is never
+# included in our generated TUs (see runtime/cpp/include/tpy/stdlib/pcre2_h.hpp
+# header comment) -- the preprocessor never sees a `#define PCRE2_CASELESS`
+# in the same TU as our constant declaration. Values are part of PCRE2's
+# stable ABI.
+
+PCRE2_CASELESS:                     Final[UInt32] = 0x00000008
+PCRE2_MULTILINE:                    Final[UInt32] = 0x00000400
+PCRE2_DOTALL:                       Final[UInt32] = 0x00000020
+PCRE2_EXTENDED:                     Final[UInt32] = 0x00000080
+PCRE2_UTF:                          Final[UInt32] = 0x00080000
+PCRE2_UCP:                          Final[UInt32] = 0x00020000
+PCRE2_ANCHORED:                     Final[UInt32] = 0x80000000
+PCRE2_ENDANCHORED:                  Final[UInt32] = 0x20000000
+
+# Match-step option for pcre2_substitute.
+PCRE2_SUBSTITUTE_GLOBAL:            Final[UInt32] = 0x00000100
+PCRE2_SUBSTITUTE_OVERFLOW_LENGTH:   Final[UInt32] = 0x00001000
+
+# pcre2_jit_compile selector: full JIT for normal matching.
+PCRE2_JIT_COMPLETE:                 Final[UInt32] = 0x00000001
+
+# Pattern-info selectors for pcre2_pattern_info.
+PCRE2_INFO_CAPTURECOUNT:            Final[UInt32] = 4
+
+# pcre2_match return codes. NOMATCH means "no match" (not an error);
+# NOMEMORY is returned by pcre2_substitute when the output buffer is
+# too small AND PCRE2_SUBSTITUTE_OVERFLOW_LENGTH is set.
+PCRE2_ERROR_NOMATCH:                Final[Int32] = -1
+PCRE2_ERROR_NOMEMORY:               Final[Int32] = -48
+
+# Sentinel meaning "this group did not participate". PCRE2_UNSET is
+# (PCRE2_SIZE)~0u = SIZE_MAX in C; we compare against it via raw uint64.
+PCRE2_UNSET:                        Final[UInt64] = 0xFFFFFFFFFFFFFFFF
+
+
+# ---------- Compile / free ----------
+# Every binding below is a pure `@native` 1:1 mirror of PCRE2's C ABI.
+# Arguments match pcre2.h exactly. Context-pointer args
+# (pcre2_compile_context*, pcre2_general_context*, etc.) are typed as
+# bare `Ptr[X]`; callers pass `None` (codegens to `nullptr`).
+
+@native("::pcre2_compile_8")
+def compile(pattern_data: Ptr[readonly[UInt8]], pattern_len: UInt64,
+            flags: UInt32,
+            errcode_out: Ptr[Int32], erroff_out: Ptr[UInt64],
+            ccontext: Ptr[CompileContext]) -> Ptr[Code]: ...
+
+@native("::pcre2_code_free_8")
+def code_free(code: Ptr[Code]) -> None: ...
+
+@native("::pcre2_jit_compile_8")
+def jit_compile(code: Ptr[Code], opts: UInt32) -> Int32: ...
+
+# Render a PCRE2 numeric error into a human-readable message. Writes into
+# the caller-provided buffer and returns the number of bytes written
+# (negative on error). `PCRE2_UCHAR8` is `uint8_t` -- same as `Ptr[UInt8]`'s
+# underlying C type, so no cast needed.
+@native("::pcre2_get_error_message_8")
+def get_error_message(errcode: Int32, buf: Ptr[UInt8], buflen: UInt64) -> Int32: ...
+
+
+# ---------- Match contexts and match-data blocks ----------
+
+@native("::pcre2_match_context_create_8")
+def match_context_create(
+    gcontext: Ptr[GeneralContext]) -> Ptr[MatchContext]: ...
+
+@native("::pcre2_match_context_free_8")
+def match_context_free(mctx: Ptr[MatchContext]) -> None: ...
+
+@native("::pcre2_match_data_create_from_pattern_8")
+def match_data_create_from_pattern(
+    code: Ptr[Code],
+    gcontext: Ptr[GeneralContext]) -> Ptr[MatchData]: ...
+
+@native("::pcre2_match_data_free_8")
+def match_data_free(md: Ptr[MatchData]) -> None: ...
+
+
+# ---------- Matching ----------
+
+# pcre2_match returns >0 on success (count of matched groups including
+# group 0), 0 if the ovector was too small (we always size correctly via
+# match_data_create_from_pattern), or negative on no-match / error.
+@native("::pcre2_match_8")
+def match(code: Ptr[Code],
+          subject_data: Ptr[readonly[UInt8]], subject_len: UInt64,
+          start_offset: UInt64, opts: UInt32,
+          md: Ptr[MatchData], mctx: Ptr[MatchContext]) -> Int32: ...
+
+# Returns Ptr[UInt64] -- pointer into the match-data block holding the
+# ovector (pairs of (start, end) byte offsets, length 2*group_count).
+@native("::pcre2_get_ovector_pointer_8")
+def get_ovector_pointer(md: Ptr[MatchData]) -> Ptr[readonly[UInt64]]: ...
+
+
+# ---------- Pattern info ----------
+
+# pcre2_pattern_info(code, what, where) -- writes the requested info into
+# `where` (typed appropriately for the selector). We only use it to fetch
+# the capture count (uint32_t).
+@native("::pcre2_pattern_info_8")
+def pattern_info_u32(code: Ptr[Code], what: UInt32, out: Ptr[UInt32]) -> Int32: ...
+
+
+# ---------- Substitution ----------
+
+# pcre2_substitute writes the result into a caller-provided UCHAR buffer.
+# If the buffer is too small AND PCRE2_SUBSTITUTE_OVERFLOW_LENGTH is set,
+# *outlen is updated to the size needed and PCRE2_ERROR_NOMEMORY returned;
+# the caller can resize and retry. `mcache` is an optional match_data cache
+# we don't use -- pass None.
+@native("::pcre2_substitute_8")
+def substitute(code: Ptr[Code],
+               subject_data: Ptr[readonly[UInt8]], subject_len: UInt64,
+               start_offset: UInt64, opts: UInt32,
+               mcache: Ptr[MatchData],
+               mctx: Ptr[MatchContext],
+               repl_data: Ptr[readonly[UInt8]], repl_len: UInt64,
+               outbuf: Ptr[UInt8], outlen_inout: Ptr[UInt64]) -> Int32: ...

tpyc/_data/lib/tpy/_bindings/posix_socket.py

@@ -0,0 +1,161 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::_bindings::posix_socket")
+# tpy: include("<tpy/stdlib/socket_h.hpp>")
+"""Raw POSIX-sockets C bindings.
+
+Thin @native layer over libc's `socket`, `bind`, `connect`, ..., plus
+three out-of-line helpers from runtime/cpp/src/stdlib/socket_impl.cpp
+(DNS resolution, errno access, last-resolve-error). One declaration per
+primitive, matching the C ABI 1:1 -- no Python semantics.
+
+Consumers (the public `socket` facade) build Socket / SocketError classes
+on top of these raw handles, using __del__ for RAII over file descriptors.
+
+Naming:
+  * `SockaddrIn` -- @native(binding="C") struct aliased to `sockaddr_in`.
+    Fields match POSIX layout (16 bytes total); safe across Linux, *BSD,
+    macOS. IPv6 (`sockaddr_in6`) is a separate struct, deferred.
+  * All function names mirror their libc counterparts.
+  * Wire values (AF_INET etc.) live in the public `socket` facade, not
+    here -- posix_socket.py is declaration-only.
+
+The `# tpy: native_module` directive means no .cpp/.hpp is generated for
+this module itself; its @native bindings resolve at link time to symbols
+in libc (for the socket/bind/... set) and in socket_impl.cpp (for the
+tpy_* set).
+"""
+
+from tpy import Int32, UInt8, UInt16, UInt32, UInt64, Int64, Ptr, readonly
+from tpy.extern import native
+
+
+# ---------- sockaddr_in (POSIX-stable 16-byte layout) ----------
+# Mirror of the `struct sockaddr_in` declaration in socket_h.hpp. TPy-side
+# field access codegens to normal C struct field access; no unsafe_load
+# is needed. Constants for sin_family / sin_port / sin_addr are built by
+# the caller using htons() + tpy_resolve_ipv4() + the AF_* values in the
+# public `socket` facade.
+@native("sockaddr_in", binding="C")
+class SockaddrIn:
+    sin_family: UInt16
+    sin_port: UInt16
+    sin_addr: UInt32
+
+
+# ---------- Socket lifecycle ----------
+
+# All @native names below use a leading `::` to bind to libc's global
+# symbols (`::socket`, `::bind`, ...). Without the `::` prefix, the rename
+# would be treated as relative to this module's `cpp_namespace` and emit
+# `::tpystd::_bindings::posix_socket::socket` -- no such symbol. Absolute
+# renames (containing `::` anywhere in the string) opt out of the
+# namespace prefix, which is what we want for libc bindings.
+
+@native("::socket")
+def socket(domain: Int32, type_: Int32, protocol: Int32) -> Int32: ...
+
+@native("::close")
+def close(fd: Int32) -> Int32: ...
+
+@native("::shutdown")
+def shutdown(fd: Int32, how: Int32) -> Int32: ...
+
+
+# ---------- Address binding + connection setup ----------
+
+@native("::bind")
+def bind(fd: Int32, addr: Ptr[SockaddrIn], addrlen: UInt32) -> Int32: ...
+
+@native("::connect")
+def connect(fd: Int32, addr: Ptr[SockaddrIn], addrlen: UInt32) -> Int32: ...
+
+@native("::listen")
+def listen(fd: Int32, backlog: Int32) -> Int32: ...
+
+@native("::accept")
+def accept(fd: Int32, addr: Ptr[SockaddrIn], addrlen: Ptr[UInt32]) -> Int32: ...
+
+
+# ---------- Data transfer ----------
+# send/recv return ssize_t (= long on 64-bit *nix). Negative means error;
+# 0 from recv means peer closed (orderly shutdown).
+
+@native("::send")
+def send(fd: Int32, buf: Ptr[readonly[UInt8]], len_: UInt64, flags: Int32) -> Int64: ...
+
+@native("::recv")
+def recv(fd: Int32, buf: Ptr[UInt8], len_: UInt64, flags: Int32) -> Int64: ...
+
+
+# ---------- Options + introspection ----------
+# setsockopt's `optval` is polymorphic (int* for boolean-style opts,
+# struct timeval* for timeouts, etc.). Phase 1 only exposes int-valued
+# options; broader shapes arrive with SO_RCVTIMEO / SO_LINGER support.
+
+@native("::setsockopt")
+def setsockopt(fd: Int32, level: Int32, optname: Int32,
+               optval: Ptr[readonly[Int32]], optlen: UInt32) -> Int32: ...
+
+@native("::getsockname")
+def getsockname(fd: Int32, addr: Ptr[SockaddrIn], addrlen: Ptr[UInt32]) -> Int32: ...
+
+@native("::getpeername")
+def getpeername(fd: Int32, addr: Ptr[SockaddrIn], addrlen: Ptr[UInt32]) -> Int32: ...
+
+@native("::socketpair")
+def socketpair(domain: Int32, type_: Int32, protocol: Int32,
+               sv: Ptr[Int32]) -> Int32: ...
+
+
+# ---------- Byte-order + address conversion ----------
+
+@native("::htons")
+def htons(hostshort: UInt16) -> UInt16: ...
+
+@native("::ntohs")
+def ntohs(netshort: UInt16) -> UInt16: ...
+
+# inet_pton writes the binary form (4 bytes for AF_INET) into `dst`.
+# Returns 1 on success, 0 for bad format, -1 for unsupported family.
+@native("::inet_pton")
+def inet_pton(af: Int32, src: Ptr[readonly[UInt8]], dst: Ptr[UInt8]) -> Int32: ...
+
+# inet_ntop writes the text form into `dst` and returns a pointer into it
+# on success, NULL on error. We accept the non-null-terminated return
+# semantics implicitly by copying via dst's span.
+@native("::inet_ntop")
+def inet_ntop(af: Int32, src: Ptr[readonly[UInt8]],
+              dst: Ptr[UInt8], size: UInt32) -> Ptr[UInt8]: ...
+
+
+# ---------- TPy runtime helpers (socket_impl.cpp) ----------
+
+# Resolve `host` (first `host_len` bytes, not required null-terminated) to
+# a single IPv4 address via getaddrinfo. Writes 4 network-byte-order bytes
+# to `out`. Returns 0 on success, -1 on failure; caller reads
+# tpy_last_resolve_error for a human message on failure.
+@native("::tpy_resolve_ipv4")
+def tpy_resolve_ipv4(host: Ptr[readonly[UInt8]], host_len: UInt64,
+                     out: Ptr[UInt8]) -> Int32: ...
+
+# errno at the point of call. Indirection for platform portability
+# (glibc uses __errno_location, macOS uses __error).
+@native("::tpy_errno")
+def tpy_errno() -> Int32: ...
+
+# Last DNS-resolution error message (thread-local, C string, valid until
+# the next tpy_resolve_ipv4 call on this thread). readonly because the
+# C signature is `const char*` -- callers must not mutate the buffer.
+@native("::tpy_last_resolve_error")
+def tpy_last_resolve_error() -> Ptr[readonly[UInt8]]: ...
+
+
+# ---------- Raw libc strerror ----------
+# Returns a human-readable description of `errnum`. Null-terminated C
+# string; caller wraps it in a TPy `str` via the usual ptr+length walk.
+# No `# tpy: include` needed for this -- <cstring> is transitively pulled
+# in via tpy.hpp, which declares `char* strerror(int)`. uint8_t* return
+# matches TPy's byte-buffer convention; ABI is identical. readonly because
+# libc's strerror buffer is thread-local / shared and must not be written.
+@native("::strerror")
+def strerror(errnum: Int32) -> Ptr[readonly[UInt8]]: ...

tpyc/_data/lib/tpy/_functools_macros.py

@@ -0,0 +1,80 @@
+# tpy: macro_module
+"""Compile-time class macros for `functools`.
+
+Hosts `@total_ordering`; the runtime helpers (`reduce`, etc.) live
+in `lib/tpy/functools.py`. The split exists because TPy modules
+cannot mix `# tpy: macro_module` with runtime functions that
+compile to C++.
+"""
+
+from tpyc.macro_api import ClassInfo, MacroError, class_macro, ast, types
+from _macro_helpers import ORDER_DUNDERS, ORDER_DUNDER_OPS
+
+
+_ANCHOR_TO_OP = dict(zip(ORDER_DUNDERS, ORDER_DUNDER_OPS))
+
+
+# (anchor, missing_op) -> builder taking `(sa, eq)` where
+# `sa = self <anchor_op> other` and `eq = self == other`.
+# Each pair has one canonical derivation; `__lt__` and `__gt__`
+# (likewise `__le__` and `__ge__`) share formulas because each
+# strict / weak inequality lets us derive its mirror identically.
+_DERIVATIONS = {
+    ("__lt__", "__gt__"): lambda sa, eq: ast.unary("!", ast.binop(sa, "||", eq)),
+    ("__lt__", "__le__"): lambda sa, eq: ast.binop(sa, "||", eq),
+    ("__lt__", "__ge__"): lambda sa, eq: ast.unary("!", sa),
+    ("__le__", "__ge__"): lambda sa, eq: ast.binop(ast.unary("!", sa), "||", eq),
+    ("__le__", "__lt__"): lambda sa, eq: ast.binop(sa, "&&", ast.unary("!", eq)),
+    ("__le__", "__gt__"): lambda sa, eq: ast.unary("!", sa),
+    ("__gt__", "__lt__"): lambda sa, eq: ast.unary("!", ast.binop(sa, "||", eq)),
+    ("__gt__", "__ge__"): lambda sa, eq: ast.binop(sa, "||", eq),
+    ("__gt__", "__le__"): lambda sa, eq: ast.unary("!", sa),
+    ("__ge__", "__le__"): lambda sa, eq: ast.binop(ast.unary("!", sa), "||", eq),
+    ("__ge__", "__gt__"): lambda sa, eq: ast.binop(sa, "&&", ast.unary("!", eq)),
+    ("__ge__", "__lt__"): lambda sa, eq: ast.unary("!", sa),
+}
+
+
+def _build_body(anchor: str, op_name: str):
+    s = ast.name("self")
+    o = ast.name("other")
+    sa = ast.binop(s, _ANCHOR_TO_OP[anchor], o)
+    eq = ast.binop(s, "==", o)
+    return _DERIVATIONS[(anchor, op_name)](sa, eq)
+
+
+@class_macro
+def total_ordering(cls: ClassInfo) -> None:
+    """Synthesize the missing rich-comparison operators on `cls`.
+
+    Requires `__eq__` plus at least one of `__lt__` / `__le__` /
+    `__gt__` / `__ge__`. The first defined ordering op (in that
+    order) is the "anchor"; the remaining three are derived from it
+    and `__eq__`. Defers the actual synthesis so peer macros like
+    `@dataclass` (which adds `__eq__`) compose regardless of
+    decorator order.
+    """
+    cls.defer_until_macros_complete(_apply_total_ordering)
+
+
+def _apply_total_ordering(cls: ClassInfo) -> None:
+    if not cls.has_method_or_inherited("__eq__"):
+        raise MacroError(
+            f"@total_ordering requires {cls.name!r} to define __eq__"
+        )
+    defined = [name for name in ORDER_DUNDERS if cls.has_method_or_inherited(name)]
+    if not defined:
+        raise MacroError(
+            f"@total_ordering requires {cls.name!r} to define one of "
+            f"__lt__, __le__, __gt__, __ge__"
+        )
+    anchor = defined[0]
+    other_type = types.named(cls.name)
+    for op_name in ORDER_DUNDERS:
+        if op_name == anchor or cls.has_method_or_inherited(op_name):
+            continue
+        cls.add_method(ast.function(
+            op_name, [("other", other_type)], types.bool,
+            [ast.return_(_build_body(anchor, op_name))],
+            is_method=True, is_readonly=True,
+        ))

tpyc/_data/lib/tpy/_macro_helpers.py

@@ -0,0 +1,161 @@
+# tpy: macro_module
+"""Shared helpers for TurboPython macro modules.
+
+Provides build_* functions for synthesizing common dunder methods
+(__init__, __eq__, __repr__, __hash__, ordering). Used by @dataclass,
+@model, and other class macros.
+"""
+
+from tpyc.macro_api import (
+    ClassInfo, FieldInfo, ast, types, Expr, Stmt, Function, Type,
+)
+
+
+# Rich-comparison dunders in CPython's documented anchor-priority
+# order, paired with the corresponding binary operator. Used by
+# `build_order` (synthesize all four for `@dataclass(order=True)`)
+# and `@total_ordering` (pick the first defined op as anchor).
+ORDER_DUNDERS = ("__lt__", "__le__", "__gt__", "__ge__")
+ORDER_DUNDER_OPS = ("<", "<=", ">", ">=")
+
+
+def build_init(
+    cls: ClassInfo,
+    parent_fields: list[FieldInfo],
+    own_fields: list[FieldInfo],
+) -> Function:
+    """Build a synthetic __init__ method from field lists."""
+    params: list[tuple[str, Type]] = []
+    defaults: list[Expr | None] = []
+    body: list[Stmt] = []
+
+    # Parent fields come first; forwarded via super().__init__()
+    for fld in parent_fields:
+        param_type = fld.type.raw_type
+        if not param_type.is_value_type():
+            param_type = types.own(param_type)
+        params.append((fld.name, param_type))
+        defaults.append(fld.default_expr)
+
+    if parent_fields:
+        super_args = [ast.name(fld.name) for fld in parent_fields]
+        super_call = ast.method_call(
+            ast.call("super"), "__init__", super_args,
+        )
+        body.append(ast.expr_stmt(super_call))
+
+    # Own fields
+    for fld in own_fields:
+        param_type = fld.type.raw_type
+        if not param_type.is_value_type():
+            param_type = types.own(param_type)
+        params.append((fld.name, param_type))
+        defaults.append(fld.default_expr)
+        body.append(ast.assign(
+            ast.field_access(ast.name("self"), fld.name),
+            ast.name(fld.name),
+        ))
+
+    return ast.function(
+        "__init__", params, types.void, body,
+        is_method=True, defaults=defaults,
+    )
+
+
+def build_eq(cls: ClassInfo, all_fields: list[FieldInfo]) -> Function:
+    """Build a synthetic __eq__ method from field list."""
+    other_type = types.named(cls.name)
+    comparisons = [
+        ast.binop(
+            ast.field_access(ast.name("self"), fld.name),
+            "==",
+            ast.field_access(ast.name("other"), fld.name),
+        )
+        for fld in all_fields
+    ]
+    if not comparisons:
+        return ast.function(
+            "__eq__", [("other", other_type)], types.bool, [ast.return_(ast.bool_lit(True))],
+            is_method=True,
+        )
+    eq_expr: Expr = comparisons[0]
+    for cmp in comparisons[1:]:
+        eq_expr = ast.binop(eq_expr, "&&", cmp)
+
+    return ast.function(
+        "__eq__", [("other", other_type)], types.bool, [ast.return_(eq_expr)],
+        is_method=True,
+    )
+
+
+def build_repr(cls: ClassInfo, all_fields: list[FieldInfo]) -> Function:
+    """Build a synthetic __repr__ method from field list.
+
+    Generates: f"ClassName(field1={repr(self.field1)}, field2={repr(self.field2)})"
+    """
+    parts = ", ".join(
+        f"{fld.name}={{repr(self.{fld.name})}}" for fld in all_fields
+    )
+    source = f'f"{cls.name}({parts})"'
+    return ast.function(
+        "__repr__", [], types.str,
+        [ast.return_(ast.quote_expr(source))],
+        is_method=True, is_readonly=True,
+    )
+
+
+def build_hash(cls: ClassInfo, all_fields: list[FieldInfo]) -> Function:
+    """Build a synthetic __hash__ method from field list.
+
+    XORs hash(field) values. Simple but has known weaknesses (symmetric
+    collisions, self-cancellation). Good enough until tuple hashing lands,
+    at which point this becomes hash((self.f1, self.f2, ...)).
+    """
+    body: list[Stmt] = []
+
+    first = all_fields[0]
+    body.append(ast.var_decl(
+        "h", types.uint64,
+        ast.call("hash", [ast.field_access(ast.name("self"), first.name)]),
+    ))
+
+    for fld in all_fields[1:]:
+        hash_call = ast.call("hash", [ast.field_access(ast.name("self"), fld.name)])
+        body.append(ast.assign(
+            ast.name("h"),
+            ast.binop(ast.name("h"), "^", hash_call),
+        ))
+
+    body.append(ast.return_(ast.name("h")))
+    return ast.function(
+        "__hash__", [], types.uint64, body,
+        is_method=True, is_readonly=True,
+    )
+
+
+def build_order(cls: ClassInfo, all_fields: list[FieldInfo]) -> list[Function]:
+    """Build synthetic ordering methods (__lt__, __le__, __gt__, __ge__).
+
+    Uses field-by-field chained comparison (lexicographic order).
+    """
+    other_type = types.named(cls.name)
+    results: list[Function] = []
+    for dunder, op in zip(ORDER_DUNDERS, ORDER_DUNDER_OPS):
+        body: list[Stmt] = []
+        for fld in all_fields[:-1]:
+            sf = ast.field_access(ast.name("self"), fld.name)
+            of = ast.field_access(ast.name("other"), fld.name)
+            body.append(ast.if_(
+                ast.binop(sf, "!=", of),
+                [ast.return_(ast.binop(sf, op, of))],
+            ))
+        last = all_fields[-1]
+        sf = ast.field_access(ast.name("self"), last.name)
+        of = ast.field_access(ast.name("other"), last.name)
+        body.append(ast.return_(ast.binop(sf, op, of)))
+
+        results.append(ast.function(
+            dunder, [("other", other_type)], types.bool, body,
+            is_method=True, is_readonly=True,
+        ))
+    return results