@shd101wyy/yo 0.1.29 → 0.1.31

package/std/libc/stdatomic.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdatomic.h>` — atomic operations and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdatomic.h>",
   // Atomic types
@@ -137,6 +138,209 @@ c_include(
   ATOMIC_LLONG_LOCK_FREE : i32,
   ATOMIC_POINTER_LOCK_FREE : i32
 );
+// SAFETY: C11 atomic typedefs (atomic_bool, atomic_int, etc.) are opaque C
+// types backed by _Atomic-qualified primitives. They contain no heap
+// allocations or thread-local state — they are trivially safe to send
+// across threads. They are Acyclic because they don't participate in Yo's
+// ARC reference-counting cycle analysis.
+impl(atomic_bool, Send());
+impl(atomic_bool, Acyclic());
+impl(atomic_char, Send());
+impl(atomic_char, Acyclic());
+impl(atomic_schar, Send());
+impl(atomic_schar, Acyclic());
+impl(atomic_uchar, Send());
+impl(atomic_uchar, Acyclic());
+impl(atomic_short, Send());
+impl(atomic_short, Acyclic());
+impl(atomic_ushort, Send());
+impl(atomic_ushort, Acyclic());
+impl(atomic_int, Send());
+impl(atomic_int, Acyclic());
+impl(atomic_uint, Send());
+impl(atomic_uint, Acyclic());
+impl(atomic_long, Send());
+impl(atomic_long, Acyclic());
+impl(atomic_ulong, Send());
+impl(atomic_ulong, Acyclic());
+impl(atomic_llong, Send());
+impl(atomic_llong, Acyclic());
+impl(atomic_ullong, Send());
+impl(atomic_ullong, Acyclic());
+impl(atomic_char16_t, Send());
+impl(atomic_char16_t, Acyclic());
+impl(atomic_char32_t, Send());
+impl(atomic_char32_t, Acyclic());
+impl(atomic_wchar_t, Send());
+impl(atomic_wchar_t, Acyclic());
+impl(atomic_int_least8_t, Send());
+impl(atomic_int_least8_t, Acyclic());
+impl(atomic_uint_least8_t, Send());
+impl(atomic_uint_least8_t, Acyclic());
+impl(atomic_int_least16_t, Send());
+impl(atomic_int_least16_t, Acyclic());
+impl(atomic_uint_least16_t, Send());
+impl(atomic_uint_least16_t, Acyclic());
+impl(atomic_int_least32_t, Send());
+impl(atomic_int_least32_t, Acyclic());
+impl(atomic_uint_least32_t, Send());
+impl(atomic_uint_least32_t, Acyclic());
+impl(atomic_int_least64_t, Send());
+impl(atomic_int_least64_t, Acyclic());
+impl(atomic_uint_least64_t, Send());
+impl(atomic_uint_least64_t, Acyclic());
+impl(atomic_int_fast8_t, Send());
+impl(atomic_int_fast8_t, Acyclic());
+impl(atomic_uint_fast8_t, Send());
+impl(atomic_uint_fast8_t, Acyclic());
+impl(atomic_int_fast16_t, Send());
+impl(atomic_int_fast16_t, Acyclic());
+impl(atomic_uint_fast16_t, Send());
+impl(atomic_uint_fast16_t, Acyclic());
+impl(atomic_int_fast32_t, Send());
+impl(atomic_int_fast32_t, Acyclic());
+impl(atomic_uint_fast32_t, Send());
+impl(atomic_uint_fast32_t, Acyclic());
+impl(atomic_int_fast64_t, Send());
+impl(atomic_int_fast64_t, Acyclic());
+impl(atomic_uint_fast64_t, Send());
+impl(atomic_uint_fast64_t, Acyclic());
+impl(atomic_intptr_t, Send());
+impl(atomic_intptr_t, Acyclic());
+impl(atomic_uintptr_t, Send());
+impl(atomic_uintptr_t, Acyclic());
+impl(atomic_size_t, Send());
+impl(atomic_size_t, Acyclic());
+impl(atomic_ptrdiff_t, Send());
+impl(atomic_ptrdiff_t, Acyclic());
+impl(atomic_intmax_t, Send());
+impl(atomic_intmax_t, Acyclic());
+impl(atomic_uintmax_t, Send());
+impl(atomic_uintmax_t, Acyclic());
+// Phase C (THREAD_SAFETY): int-specific atomic operations. The c_include
+// block only declares load/store/exchange for atomic_bool. These Yo-runtime
+// wrappers forward to the C11 _Generic macros in <stdatomic.h> so AtomicI32
+// can use the full atomic API.
+extern(
+  "Yo",
+  __yo_atomic_load_int :
+    fn(obj : *(atomic_int), order : memory_order) -> i32,
+  __yo_atomic_store_int :
+    fn(obj : *(atomic_int), desired : i32, order : memory_order) -> unit,
+  __yo_atomic_exchange_int :
+    fn(obj : *(atomic_int), desired : i32, order : memory_order) -> i32,
+  __yo_atomic_compare_exchange_int :
+    fn(
+      obj : *(atomic_int),
+      expected : *(i32),
+      desired : i32,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool
+);
+// Phase C: size_t-specific atomic operations (for AtomicUsize)
+extern(
+  "Yo",
+  __yo_atomic_load_size_t :
+    fn(obj : *(atomic_size_t), order : memory_order) -> usize,
+  __yo_atomic_store_size_t :
+    fn(obj : *(atomic_size_t), desired : usize, order : memory_order) -> unit,
+  __yo_atomic_exchange_size_t :
+    fn(obj : *(atomic_size_t), desired : usize, order : memory_order) -> usize,
+  __yo_atomic_compare_exchange_size_t :
+    fn(
+      obj : *(atomic_size_t),
+      expected : *(usize),
+      desired : usize,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool
+);
+// Phase C: long-long-specific atomic operations (for AtomicI64)
+extern(
+  "Yo",
+  __yo_atomic_load_llong :
+    fn(obj : *(atomic_llong), order : memory_order) -> i64,
+  __yo_atomic_store_llong :
+    fn(obj : *(atomic_llong), desired : i64, order : memory_order) -> unit,
+  __yo_atomic_exchange_llong :
+    fn(obj : *(atomic_llong), desired : i64, order : memory_order) -> i64,
+  __yo_atomic_compare_exchange_llong :
+    fn(
+      obj : *(atomic_llong),
+      expected : *(i64),
+      desired : i64,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool
+);
+// Phase C: remaining atomic type wrappers
+extern(
+  "Yo",
+  __yo_atomic_load_schar :
+    fn(obj : *(atomic_schar), order : memory_order) -> i8,
+  __yo_atomic_store_schar :
+    fn(obj : *(atomic_schar), desired : i8, order : memory_order) -> unit,
+  __yo_atomic_exchange_schar :
+    fn(obj : *(atomic_schar), desired : i8, order : memory_order) -> i8,
+  __yo_atomic_compare_exchange_schar :
+    fn(obj : *(atomic_schar), expected : *(i8), desired : i8,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_short :
+    fn(obj : *(atomic_short), order : memory_order) -> i16,
+  __yo_atomic_store_short :
+    fn(obj : *(atomic_short), desired : i16, order : memory_order) -> unit,
+  __yo_atomic_exchange_short :
+    fn(obj : *(atomic_short), desired : i16, order : memory_order) -> i16,
+  __yo_atomic_compare_exchange_short :
+    fn(obj : *(atomic_short), expected : *(i16), desired : i16,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_uchar :
+    fn(obj : *(atomic_uchar), order : memory_order) -> u8,
+  __yo_atomic_store_uchar :
+    fn(obj : *(atomic_uchar), desired : u8, order : memory_order) -> unit,
+  __yo_atomic_exchange_uchar :
+    fn(obj : *(atomic_uchar), desired : u8, order : memory_order) -> u8,
+  __yo_atomic_compare_exchange_uchar :
+    fn(obj : *(atomic_uchar), expected : *(u8), desired : u8,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_ushort :
+    fn(obj : *(atomic_ushort), order : memory_order) -> u16,
+  __yo_atomic_store_ushort :
+    fn(obj : *(atomic_ushort), desired : u16, order : memory_order) -> unit,
+  __yo_atomic_exchange_ushort :
+    fn(obj : *(atomic_ushort), desired : u16, order : memory_order) -> u16,
+  __yo_atomic_compare_exchange_ushort :
+    fn(obj : *(atomic_ushort), expected : *(u16), desired : u16,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_uint :
+    fn(obj : *(atomic_uint), order : memory_order) -> u32,
+  __yo_atomic_store_uint :
+    fn(obj : *(atomic_uint), desired : u32, order : memory_order) -> unit,
+  __yo_atomic_exchange_uint :
+    fn(obj : *(atomic_uint), desired : u32, order : memory_order) -> u32,
+  __yo_atomic_compare_exchange_uint :
+    fn(obj : *(atomic_uint), expected : *(u32), desired : u32,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_ullong :
+    fn(obj : *(atomic_ullong), order : memory_order) -> u64,
+  __yo_atomic_store_ullong :
+    fn(obj : *(atomic_ullong), desired : u64, order : memory_order) -> unit,
+  __yo_atomic_exchange_ullong :
+    fn(obj : *(atomic_ullong), desired : u64, order : memory_order) -> u64,
+  __yo_atomic_compare_exchange_ullong :
+    fn(obj : *(atomic_ullong), expected : *(u64), desired : u64,
+       success : memory_order, failure : memory_order) -> bool,
+  __yo_atomic_load_ptrdiff :
+    fn(obj : *(atomic_ptrdiff_t), order : memory_order) -> isize,
+  __yo_atomic_store_ptrdiff :
+    fn(obj : *(atomic_ptrdiff_t), desired : isize, order : memory_order) -> unit,
+  __yo_atomic_exchange_ptrdiff :
+    fn(obj : *(atomic_ptrdiff_t), desired : isize, order : memory_order) -> isize,
+  __yo_atomic_compare_exchange_ptrdiff :
+    fn(obj : *(atomic_ptrdiff_t), expected : *(isize), desired : isize,
+       success : memory_order, failure : memory_order) -> bool
+);
 export(
   // Atomic types
   atomic_bool,
@@ -237,5 +441,51 @@ export(
   ATOMIC_LLONG_LOCK_FREE,
   ATOMIC_POINTER_LOCK_FREE,
   // Kill dependency
-  kill_dependency
+  kill_dependency,
+  // Phase C (THREAD_SAFETY): int-specific atomic wrappers
+  __yo_atomic_load_int,
+  __yo_atomic_store_int,
+  __yo_atomic_exchange_int,
+  __yo_atomic_compare_exchange_int,
+  // Phase C: size_t atomic wrappers
+  __yo_atomic_load_size_t,
+  __yo_atomic_store_size_t,
+  __yo_atomic_exchange_size_t,
+  __yo_atomic_compare_exchange_size_t,
+  // Phase C: llong atomic wrappers
+  __yo_atomic_load_llong,
+  __yo_atomic_store_llong,
+  __yo_atomic_exchange_llong,
+  __yo_atomic_compare_exchange_llong,
+  // Phase C: signed narrow atomics
+  __yo_atomic_load_schar,
+  __yo_atomic_store_schar,
+  __yo_atomic_exchange_schar,
+  __yo_atomic_compare_exchange_schar,
+  __yo_atomic_load_short,
+  __yo_atomic_store_short,
+  __yo_atomic_exchange_short,
+  __yo_atomic_compare_exchange_short,
+  // Phase C: unsigned atomics
+  __yo_atomic_load_uchar,
+  __yo_atomic_store_uchar,
+  __yo_atomic_exchange_uchar,
+  __yo_atomic_compare_exchange_uchar,
+  __yo_atomic_load_ushort,
+  __yo_atomic_store_ushort,
+  __yo_atomic_exchange_ushort,
+  __yo_atomic_compare_exchange_ushort,
+  __yo_atomic_load_uint,
+  __yo_atomic_store_uint,
+  __yo_atomic_exchange_uint,
+  __yo_atomic_compare_exchange_uint,
+  __yo_atomic_load_ullong,
+  __yo_atomic_store_ullong,
+  __yo_atomic_exchange_ullong,
+  __yo_atomic_compare_exchange_ullong,
+  // Phase C: isize
+  __yo_atomic_load_ptrdiff,
+  __yo_atomic_store_ptrdiff,
+  __yo_atomic_exchange_ptrdiff,
+  __yo_atomic_compare_exchange_ptrdiff
 );

package/std/libc/stdint.yo

@@ -3,6 +3,7 @@
 //! Note: Yo already has `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`.
 //! This file provides C-compatible aliases and additional types/constants.
 // Type aliases for C compatibility (mapping Yo types to C stdint names)
+pragma(Pragma.AllowUnsafe);
 int8_t :: i8;
 int16_t :: i16;
 int32_t :: i32;

package/std/libc/stdio.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdio.h>` — standard I/O functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdio.h>",
   // Types

package/std/libc/stdlib.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdlib.h>` — general utility functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdlib.h>",
   // Types for div functions

package/std/libc/string.yo

@@ -1,4 +1,5 @@
 //! C11 `<string.h>` — string and memory functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<string.h>",
   // Memory functions

package/std/libc/sys/stat.yo

@@ -1,4 +1,5 @@
 //! POSIX `<sys/stat.h>` — file status and mode operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<sys/stat.h>",
   // Types

package/std/libc/time.yo

@@ -1,4 +1,5 @@
 //! C11 `<time.h>` — date and time functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<time.h>",
   // Types

package/std/libc/unistd.yo

@@ -1,4 +1,5 @@
 //! POSIX `<unistd.h>` — standard symbolic constants and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<unistd.h>",
   // Types

package/std/libc/wctype.yo

@@ -1,4 +1,5 @@
 //! C11 `<wctype.h>` — wide character classification and conversion functions.
+pragma(Pragma.AllowUnsafe);
 { wint_t } :: import("./stdint");
 c_include(
   "<wctype.h>",

package/std/libc/windows.yo

@@ -1,6 +1,8 @@
 //! Windows-specific C API bindings.
 //! Only available when compiling for Windows.
 // Windows type aliases (using Yo types that match the C types)
+pragma(Pragma.AllowUnsafe);
+pragma(Pragma.AllowUnsafe);
 DWORD :: ulong; // unsigned long on Windows
 WCHAR :: ushort; // unsigned short (UTF-16 code unit)
 BOOL :: int; // int

package/std/log.yo

@@ -1,4 +1,5 @@
 //! Structured logging with configurable level and output destination.
+pragma(Pragma.AllowUnsafe);
 open(import("./string"));
 { ToString } :: import("./fmt");
 { fwrite, stdout, stderr, FILE } :: import("./libc/stdio");
@@ -7,9 +8,9 @@ Level :: enum(Trace, Debug, Info, Warn, Error);
 impl(
   Level,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)(
+    to_string : (fn(ref(self) : Self) -> String)(
       match(
-        self.*,
+        self,
         .Trace => String.from("TRACE"),
         .Debug => String.from("DEBUG"),
         .Info => String.from("INFO "),
@@ -60,7 +61,7 @@ _write_string :: (fn(s : String, dest : *(FILE)) -> unit)({
   cond(
     (bytes.len() > usize(0)) => {
       ptr := bytes.ptr().unwrap();
-      fwrite(*(void)(ptr), usize(1), bytes.len(), dest);
+      unsafe(fwrite(*(void)(ptr), usize(1), bytes.len(), dest));
     },
     true => ()
   );
@@ -79,11 +80,11 @@ log :: (fn(level : Level, msg : String) -> unit)({
     .Stderr => stderr
   );
   // Write "[LEVEL] msg\n"
-  fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest));
   _write_string(level_str, dest);
-  fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest);
+  unsafe(fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest));
   _write_string(msg, dest);
-  fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest));
 });
 export(log);
 // ============================================================================

package/std/net/addr.yo

@@ -7,6 +7,7 @@
 //   { IpAddr, SocketAddr } :: import "std/net/addr";
 //
 //   addr := SocketAddr.new(IpAddr.loopback_v4(), u16(8080));
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ToString } :: import("../fmt");
 { Writer } :: import("../fmt/writer");
@@ -40,7 +41,7 @@ impl(
     val := u32(0);
     i := usize(0);
     while(runtime(i < bytes.len()), {
-      ch := bytes.get(i).unwrap();
+      ch := bytes(i);
       cond(
         (ch == _ASCII_DOT) => {
           // '.' separator
@@ -145,10 +146,10 @@ impl(
       self -> {
         return(
           match(
-            self.*,
+            self,
             .V4(a, b, c, d) => {
               buf := Array(u8, usize(16)).fill(u8(0));
-              snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+              unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d)));
               String.from_cstr(&(buf(usize(0)))).unwrap()
             },
             .V6(segs) => {
@@ -205,7 +206,7 @@ impl(
       self -> {
         ip_str := self.ip.to_string();
         buf := Array(u8, usize(8)).fill(u8(0));
-        snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port));
+        unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port)));
         port_str := String.from_cstr(&(buf(usize(0)))).unwrap();
         return(
           match(

package/std/net/dns.yo

@@ -9,14 +9,15 @@
 //   { IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
 //     addrs := io.await(lookup_host(`localhost`, io), { io, exn });
 //     i := usize(0);
 //     while runtime((i < addrs.len())), {
-//       println(addrs.get(i).unwrap().to_string());
+//       println(addrs(i).to_string());
 //       i = (i + usize(1));
 //     };
 //   });
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
@@ -24,14 +25,14 @@ open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 IO_dns :: import("../sys/dns");
 { AF_INET, AF_INET6 } :: import("../sys/socket");
 // ============================================================================
 // DNS lookup
 // ============================================================================
 /// Resolve a hostname to a list of IP addresses.
-lookup_host :: (fn(host : String, io : IO) -> Impl(Future(ArrayList(IpAddr), IOErr)))(
+lookup_host :: (fn(host : String, io : Io) -> Impl(Future(ArrayList(IpAddr), IoExn)))(
   io.async((e) => {
     host_cstr_bytes := host.to_cstr();
     host_cstr := host_cstr_bytes.ptr().unwrap();
@@ -82,13 +83,13 @@ lookup_host :: (fn(host : String, io : IO) -> Impl(Future(ArrayList(IpAddr), IOE
   })
 );
 /// Resolve a hostname and port to a list of socket addresses.
-resolve :: (fn(host : String, port : u16, io : IO) -> Impl(Future(ArrayList(SocketAddr), IOErr)))(
+resolve :: (fn(host : String, port : u16, io : Io) -> Impl(Future(ArrayList(SocketAddr), IoExn)))(
   io.async((e) => {
     addrs := e.io.await(lookup_host(host, io), e);
     result := ArrayList(SocketAddr).new();
     i := usize(0);
     while(runtime(i < addrs.len()), {
-      ip := addrs.get(i).unwrap();
+      ip := addrs(i);
       result.push(SocketAddr.new(ip, port));
       i = (i + usize(1));
     });

package/std/net/errors.yo

@@ -1,12 +1,12 @@
 //! Network error types.
 // std/net/errors.yo - Network error type
 //
-// Higher-level network error that wraps IOError with network-specific variants.
+// Higher-level network error that wraps IoError with network-specific variants.
 //
 // Example:
 //   { NetError } :: import "std/net/errors";
 open(import("../string"));
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { ToString } :: import("../fmt");
 { Error, AnyError, Exception } :: import("../error");
 // ============================================================================
@@ -33,14 +33,14 @@ NetError :: enum(
   /// DNS resolution failed.
   DNSFailed(msg : String),
   /// A wrapped lower-level I/O error.
-  IO(err : IOError),
+  Io(err : IoError),
   /// An unclassified network error with a message.
   Other(msg : String)
 );
 impl(
   NetError,
-  /// Convert an `IOError` into the corresponding `NetError` variant.
-  from_io : (fn(err : IOError) -> Self)(
+  /// Convert an `IoError` into the corresponding `NetError` variant.
+  from_io : (fn(err : IoError) -> Self)(
     match(
       err,
       .ConnectionRefused =>.ConnectionRefused,
@@ -51,7 +51,7 @@ impl(
       .TimedOut =>.TimedOut,
       .HostUnreachable =>.HostUnreachable,
       .NetworkUnreachable =>.NetworkUnreachable,
-      _ =>.IO(err)
+      _ =>.Io(err)
     )
   )
 );
@@ -71,7 +71,7 @@ impl(
           .HostUnreachable => String.from("host unreachable"),
           .NetworkUnreachable => String.from("network unreachable"),
           .DNSFailed(msg) => `DNS lookup failed: ${msg}`,
-          .IO(err) => err.to_string(),
+          .Io(err) => err.to_string(),
           .Other(msg) => msg
         );
         return(s);
@@ -87,7 +87,7 @@ impl(
   check : (fn(result : i32, exn : Exception) -> i32)(
     cond(
       (result >= i32(0)) => result,
-      true => exn.throw(dyn(Self.from_io(IOError.from_errno(i32(0) - result))))
+      true => exn.throw(dyn(Self.from_io(IoError.from_errno(i32(0) - result))))
     )
   )
 );