@shd101wyy/yo 0.1.29 → 0.1.30

package/std/fs/file.yo

@@ -8,7 +8,7 @@
 //! ```rust
 //! { File, read_string, write_file, OpenMode } :: import "std/fs/file";
 //!
-//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
 //!   // Write a file
 //!   io.await(write_file(Path.new(`test.txt`), `hello world`, io), { io, exn });
 //!
@@ -20,14 +20,15 @@
 //!   f := io.await(File.open(Path.new(`test.txt`), .Read, io), { io, exn });
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
 open(import("../string"));
 open(import("../fmt"));
 { Path } :: import("../path");
-{ IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ IoError } :: import("../sys/errors");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 { Metadata } :: import("./metadata");
 _metadata_mod :: import("./metadata");
 { Statx } :: import("../sys/statx");
@@ -51,7 +52,7 @@ File :: object(
 impl(
   File,
   /// Open a file at `path` with the given mode and custom permissions.
-  open_with : (fn(path : Path, mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))({
+  open_with : (fn(path : Path, mode : OpenMode, perm : FilePermission, io : Io) -> Impl(Future(File, IoExn)))({
     flags := _open_mode_to_flags(mode);
     file_mode := cond(
       _open_mode_needs_perm(mode) => i32(perm.mode),
@@ -62,7 +63,7 @@ impl(
       cstr_bytes := path_str.to_cstr();
       cstr := cstr_bytes.ptr().unwrap();
       result := e.io.await(IO_file.openat(AT_FDCWD, cstr, flags, file_mode), e.io);
-      fd := IOError.check(result, e.exn);
+      fd := IoError.check(result, e.exn);
       File(
         _fd : fd,
         _path : path,
@@ -71,37 +72,37 @@ impl(
     })
   }),
   /// Open a file from a `str` path with the given mode and custom permissions.
-  open_with_str : (fn(path : str, mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))(
+  open_with_str : (fn(path : str, mode : OpenMode, perm : FilePermission, io : Io) -> Impl(Future(File, IoExn)))(
     File.open_with(Path.new(String.from(path)), mode, perm, io)
   ),
   /// Open a file from a C string path with the given mode and custom permissions.
-  open_with_cstr : (fn(path : *(u8), mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))(
+  open_with_cstr : (fn(path : *(u8), mode : OpenMode, perm : FilePermission, io : Io) -> Impl(Future(File, IoExn)))(
     File.open_with(Path.from_cstr(path), mode, perm, io)
   ),
   /// Open a file at `path` with the given mode and default permissions (0o644).
-  open : (fn(path : Path, mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+  open : (fn(path : Path, mode : OpenMode, io : Io) -> Impl(Future(File, IoExn)))(
     File.open_with(path, mode, FilePermission.default(), io)
   ),
   /// Open a file from a `str` path with the given mode and default permissions.
-  open_str : (fn(path : str, mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+  open_str : (fn(path : str, mode : OpenMode, io : Io) -> Impl(Future(File, IoExn)))(
     File.open(Path.new(String.from(path)), mode, io)
   ),
   /// Open a file from a C string path with the given mode and default permissions.
-  open_cstr : (fn(path : *(u8), mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+  open_cstr : (fn(path : *(u8), mode : OpenMode, io : Io) -> Impl(Future(File, IoExn)))(
     File.open(Path.from_cstr(path), mode, io)
   ),
   /// Read up to `size` bytes into the buffer `buf`.
   /// Returns the number of bytes actually read.
-  read : (fn(self : Self, buf : *(u8), size : u32, io : IO) -> Impl(Future(i32, IOErr)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       result := e.io.await(IO_file.read(fd, buf, size, u64(0)), e.io);
-      IOError.check(result, e.exn)
+      IoError.check(result, e.exn)
     })
   }),
   /// Write a `String` to the file.
   /// Returns the number of bytes written.
-  write_string : (fn(self : Self, data : String, io : IO) -> Impl(Future(i32, IOErr)))({
+  write_string : (fn(self : Self, data : String, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       data_bytes := data.as_bytes();
@@ -109,14 +110,14 @@ impl(
         (data_bytes.len() == usize(0)) => i32(0),
         true => {
           result := e.io.await(IO_file.write(fd, data_bytes.ptr().unwrap(), u32(data_bytes.len()), u64(0)), e.io);
-          IOError.check(result, e.exn)
+          IoError.check(result, e.exn)
         }
       )
     })
   }),
   /// Write bytes from an `ArrayList(u8)` to the file.
   /// Returns the number of bytes written.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async(
       (e) =>
@@ -124,13 +125,13 @@ impl(
           (data.len() == usize(0)) => i32(0),
           true => {
             result := e.io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)), e.io);
-            IOError.check(result, e.exn)
+            IoError.check(result, e.exn)
           }
         )
     )
   }),
   /// Read the entire file contents into an `ArrayList(u8)`.
-  read_bytes : (fn(self : Self, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))({
+  read_bytes : (fn(self : Self, io : Io) -> Impl(Future(ArrayList(u8), IoExn)))({
     fd := self._fd;
     io.async((e) => {
       buf_size := usize(4096);
@@ -142,7 +143,7 @@ impl(
         cond(
           (n < i32(0)) => {
             free(.Some(*(void)(buf)));
-            e.exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+            e.exn.throw(dyn(IoError.from_errno(i32(0) - n)));
           },
           (n == i32(0)) => break,
           true => {
@@ -160,19 +161,19 @@ impl(
     })
   }),
   /// Read the entire file contents into a `String`.
-  read_string : (fn(self : Self, io : IO) -> Impl(Future(String, IOErr)))(
+  read_string : (fn(self : Self, io : Io) -> Impl(Future(String, IoExn)))(
     io.async((e) => {
       bytes := e.io.await(self.read_bytes(io), e);
       String.from_bytes(bytes)
     })
   ),
   /// Flush (fsync) file data to disk.
-  flush : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  flush : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       result := e.io.await(IO_file.fsync(fd), e.io);
       cond(
-        (result < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - result))),
+        (result < i32(0)) => e.exn.throw(dyn(IoError.from_errno(i32(0) - result))),
         true => ()
       )
     })
@@ -181,7 +182,7 @@ impl(
   seek : (fn(self : Self, offset : i64, from : SeekFrom, exn : Exception) -> i64)({
     result := IO_seek.lseek(self._fd, offset, _seek_from_to_whence(from));
     cond(
-      (result < i64(0)) => exn.throw(dyn(IOError.from_errno(i32(i64(0) - result)))),
+      (result < i64(0)) => exn.throw(dyn(IoError.from_errno(i32(i64(0) - result)))),
       true => result
     )
   }),
@@ -194,7 +195,7 @@ impl(
     IO_file.file_size(self._fd)
   ),
   /// Close the file descriptor. Safe to call multiple times.
-  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  close : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async(
       (e) =>
@@ -204,7 +205,7 @@ impl(
             result := e.io.await(IO_file.close(fd), e.io);
             self._is_closed = true;
             cond(
-              (result < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - result))),
+              (result < i32(0)) => e.exn.throw(dyn(IoError.from_errno(i32(0) - result))),
               true => ()
             )
           }
@@ -220,7 +221,7 @@ impl(
     self._path
   ),
   /// Get file metadata (size, permissions, timestamps).
-  metadata : (fn(self : Self, io : IO) -> Impl(Future(Metadata, IOErr)))(
+  metadata : (fn(self : Self, io : Io) -> Impl(Future(Metadata, IoExn)))(
     _metadata_mod.metadata(self._path, io)
   )
 );
@@ -243,7 +244,7 @@ export(File, OpenMode, FilePermission, SeekFrom);
 // Convenience functions
 // ============================================================================
 /// Read an entire file into a `String`.
-read_string :: (fn(path : Path, io : IO) -> Impl(Future(String, IOErr)))(
+read_string :: (fn(path : Path, io : Io) -> Impl(Future(String, IoExn)))(
   io.async((e) => {
     file := e.io.await(File.open(path,.Read, io), e);
     content := e.io.await(file.read_string(io), e);
@@ -252,15 +253,15 @@ read_string :: (fn(path : Path, io : IO) -> Impl(Future(String, IOErr)))(
   })
 );
 /// Read an entire file into a `String` (`str` path variant).
-read_string_str :: (fn(path : str, io : IO) -> Impl(Future(String, IOErr)))(
+read_string_str :: (fn(path : str, io : Io) -> Impl(Future(String, IoExn)))(
   read_string(Path.new(String.from(path)), io)
 );
 /// Read an entire file into a `String` (C string path variant).
-read_string_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(String, IOErr)))(
+read_string_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(String, IoExn)))(
   read_string(Path.from_cstr(path), io)
 );
 /// Read an entire file into a byte list (`ArrayList(u8)`).
-read_file :: (fn(path : Path, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+read_file :: (fn(path : Path, io : Io) -> Impl(Future(ArrayList(u8), IoExn)))(
   io.async((e) => {
     file := e.io.await(File.open(path,.Read, io), e);
     content := e.io.await(file.read_bytes(io), e);
@@ -269,15 +270,15 @@ read_file :: (fn(path : Path, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
   })
 );
 /// Read an entire file into bytes (`str` path variant).
-read_file_str :: (fn(path : str, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+read_file_str :: (fn(path : str, io : Io) -> Impl(Future(ArrayList(u8), IoExn)))(
   read_file(Path.new(String.from(path)), io)
 );
 /// Read an entire file into bytes (C string path variant).
-read_file_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+read_file_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(ArrayList(u8), IoExn)))(
   read_file(Path.from_cstr(path), io)
 );
 /// Write a `String` to a file, creating or truncating it.
-write_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOErr)))(
+write_file :: (fn(path : Path, data : String, io : Io) -> Impl(Future(unit, IoExn)))(
   io.async((e) => {
     file := e.io.await(File.open(path,.Write, io), e);
     e.io.await(file.write_string(data, io), e);
@@ -285,15 +286,15 @@ write_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOEr
   })
 );
 /// Write a `str` to a file, creating or truncating it (`str` path variant).
-write_file_str :: (fn(path : str, data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+write_file_str :: (fn(path : str, data : str, io : Io) -> Impl(Future(unit, IoExn)))(
   write_file(Path.new(String.from(path)), String.from(data), io)
 );
 /// Write a `str` to a file, creating or truncating it (C string path variant).
-write_file_cstr :: (fn(path : *(u8), data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+write_file_cstr :: (fn(path : *(u8), data : str, io : Io) -> Impl(Future(unit, IoExn)))(
   write_file(Path.from_cstr(path), String.from(data), io)
 );
 /// Write bytes to a file, creating or truncating it.
-write_bytes :: (fn(path : Path, data : ArrayList(u8), io : IO) -> Impl(Future(unit, IOErr)))(
+write_bytes :: (fn(path : Path, data : ArrayList(u8), io : Io) -> Impl(Future(unit, IoExn)))(
   io.async((e) => {
     file := e.io.await(File.open(path,.Write, io), e);
     e.io.await(file.write_bytes(data, io), e);
@@ -301,7 +302,7 @@ write_bytes :: (fn(path : Path, data : ArrayList(u8), io : IO) -> Impl(Future(un
   })
 );
 /// Append a `String` to a file, creating it if it does not exist.
-append_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOErr)))(
+append_file :: (fn(path : Path, data : String, io : Io) -> Impl(Future(unit, IoExn)))(
   io.async((e) => {
     file := e.io.await(File.open(path,.Append, io), e);
     e.io.await(file.write_string(data, io), e);
@@ -309,7 +310,7 @@ append_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOE
   })
 );
 /// Append a `str` to a file (`str` path variant).
-append_file_str :: (fn(path : str, data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+append_file_str :: (fn(path : str, data : str, io : Io) -> Impl(Future(unit, IoExn)))(
   append_file(Path.new(String.from(path)), String.from(data), io)
 );
 extern(
@@ -318,7 +319,7 @@ extern(
 );
 /// Check if a path exists. Returns `false` for any error including file not found.
 /// Does not use the `Exception` effect.
-exists :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+exists :: (fn(path : Path, io : Io) -> Impl(Future(bool, Io)))(
   io.async((io) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
@@ -330,15 +331,15 @@ exists :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
   })
 );
 /// Check if a path exists (`str` path variant).
-exists_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+exists_str :: (fn(path : str, io : Io) -> Impl(Future(bool, Io)))(
   exists(Path.new(String.from(path)), io)
 );
 /// Check if a path exists (C string path variant).
-exists_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+exists_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(bool, Io)))(
   exists(Path.from_cstr(path), io)
 );
 /// Check if a path is a regular file. Returns `false` for any error.
-is_file :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+is_file :: (fn(path : Path, io : Io) -> Impl(Future(bool, Io)))(
   io.async((io) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -358,15 +359,15 @@ is_file :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
   })
 );
 /// Check if a path is a regular file (`str` path variant).
-is_file_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+is_file_str :: (fn(path : str, io : Io) -> Impl(Future(bool, Io)))(
   is_file(Path.new(String.from(path)), io)
 );
 /// Check if a path is a regular file (C string path variant).
-is_file_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+is_file_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(bool, Io)))(
   is_file(Path.from_cstr(path), io)
 );
 /// Check if a path is a directory. Returns `false` for any error.
-is_dir :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+is_dir :: (fn(path : Path, io : Io) -> Impl(Future(bool, Io)))(
   io.async((io) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -386,16 +387,16 @@ is_dir :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
   })
 );
 /// Check if a path is a directory (`str` path variant).
-is_dir_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+is_dir_str :: (fn(path : str, io : Io) -> Impl(Future(bool, Io)))(
   is_dir(Path.new(String.from(path)), io)
 );
 /// Check if a path is a directory (C string path variant).
-is_dir_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+is_dir_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(bool, Io)))(
   is_dir(Path.from_cstr(path), io)
 );
 /// Resolve a path to its canonical absolute form (resolves symlinks, `.` and `..`).
 /// Throws if the path does not exist.
-canonical :: (fn(path : Path, io : IO) -> Impl(Future(Path, IOErr)))(
+canonical :: (fn(path : Path, io : Io) -> Impl(Future(Path, IoExn)))(
   io.async((e) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -405,14 +406,14 @@ canonical :: (fn(path : Path, io : IO) -> Impl(Future(Path, IOErr)))(
     stat_buf := *(u8)(malloc(buf_size).unwrap());
     stat_result := e.io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, stat_buf), e.io);
     free(.Some(*(void)(stat_buf)));
-    IOError.check(stat_result, e.exn);
+    IoError.check(stat_result, e.exn);
     // Resolve the canonical path
     resolved_buf := *(u8)(malloc(usize(4096)).unwrap());
     rp_result := IO_path.realpath(cstr, resolved_buf);
     cond(
       (rp_result < i32(0)) => {
         free(.Some(*(void)(resolved_buf)));
-        IOError.check(rp_result, e.exn);
+        IoError.check(rp_result, e.exn);
       },
       true => ()
     );
@@ -422,11 +423,11 @@ canonical :: (fn(path : Path, io : IO) -> Impl(Future(Path, IOErr)))(
   })
 );
 /// Resolve a path to its canonical absolute form (`str` path variant).
-canonical_str :: (fn(path : str, io : IO) -> Impl(Future(Path, IOErr)))(
+canonical_str :: (fn(path : str, io : Io) -> Impl(Future(Path, IoExn)))(
   canonical(Path.new(String.from(path)), io)
 );
 /// Resolve a path to its canonical absolute form (C string path variant).
-canonical_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(Path, IOErr)))(
+canonical_cstr :: (fn(path : *(u8), io : Io) -> Impl(Future(Path, IoExn)))(
   canonical(Path.from_cstr(path), io)
 );
 export(

package/std/fs/metadata.yo

@@ -6,18 +6,19 @@
 //! ```rust
 //! { metadata } :: import "std/fs/metadata";
 //!
-//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
 //!   m := io.await(metadata(Path.new(`/tmp/test.txt`), io), { io, exn });
 //!   printf("size: %lld\n", m.size());
 //!   printf("is file: %d\n", i32(m.is_file()));
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../string"));
 { Path } :: import("../path");
-{ IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ IoError } :: import("../sys/errors");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 { Statx } :: import("../sys/statx");
 IO_file :: import("../sys/file");
 { AT_FDCWD, AT_SYMLINK_NOFOLLOW, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, S_IFMT, S_IFREG, S_IFDIR, S_IFLNK, S_IWUSR, S_IWGRP, S_IWOTH } :: import("../sys/constants");
@@ -101,7 +102,7 @@ extern(
 // ============================================================================
 // Internal helper to stat a path
 // ============================================================================
-_stat_path :: (fn(path : Path, flags : i32, io : IO) -> Impl(Future(Metadata, IOErr)))(
+_stat_path :: (fn(path : Path, flags : i32, io : Io) -> Impl(Future(Metadata, IoExn)))(
   io.async((e) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
@@ -111,7 +112,7 @@ _stat_path :: (fn(path : Path, flags : i32, io : IO) -> Impl(Future(Metadata, IO
     cond(
       (result < i32(0)) => {
         free(.Some(*(void)(buf)));
-        e.exn.throw(dyn(IOError.from_errno(i32(0) - result)))
+        e.exn.throw(dyn(IoError.from_errno(i32(0) - result)))
       },
       true => {
         sx := Statx(_buf_ptr : buf, _buf_size : buf_size);
@@ -121,11 +122,11 @@ _stat_path :: (fn(path : Path, flags : i32, io : IO) -> Impl(Future(Metadata, IO
   })
 );
 /// Get metadata for a path (follows symlinks).
-metadata :: (fn(path : Path, io : IO) -> Impl(Future(Metadata, IOErr)))(_stat_path(path, AT_STATX_SYNC_AS_STAT, io));
+metadata :: (fn(path : Path, io : Io) -> Impl(Future(Metadata, IoExn)))(_stat_path(path, AT_STATX_SYNC_AS_STAT, io));
 /// Get metadata for a path given as a raw string (follows symlinks).
-metadata_str :: (fn(path : str, io : IO) -> Impl(Future(Metadata, IOErr)))(metadata(Path.new(String.from(path)), io));
+metadata_str :: (fn(path : str, io : Io) -> Impl(Future(Metadata, IoExn)))(metadata(Path.new(String.from(path)), io));
 /// Get metadata for a path (does NOT follow symlinks).
-symlink_metadata :: (fn(path : Path, io : IO) -> Impl(Future(Metadata, IOErr)))(_stat_path(path, AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT, io));
+symlink_metadata :: (fn(path : Path, io : Io) -> Impl(Future(Metadata, IoExn)))(_stat_path(path, AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT, io));
 /// Get metadata for a path given as a raw string (does NOT follow symlinks).
-symlink_metadata_str :: (fn(path : str, io : IO) -> Impl(Future(Metadata, IOErr)))(symlink_metadata(Path.new(String.from(path)), io));
+symlink_metadata_str :: (fn(path : str, io : Io) -> Impl(Future(Metadata, IoExn)))(symlink_metadata(Path.new(String.from(path)), io));
 export(metadata, metadata_str, symlink_metadata, symlink_metadata_str);

package/std/fs/temp.yo

@@ -5,19 +5,20 @@
 //! ```rust
 //! { TempDir } :: import "std/fs/temp";
 //!
-//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
 //!   dir := io.await(TempDir.new(io), { io, exn });
 //!   println(dir.path());
 //!   io.await(dir.remove(io), { io, exn });
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../string"));
 open(import("../fmt"));
 { Path } :: import("../path");
-{ IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ IoError } :: import("../sys/errors");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 _file_mod :: import("./file");
 _dir_mod :: import("./dir");
 IO_temp :: import("../sys/temp");
@@ -53,7 +54,7 @@ TempDir :: object(
 impl(
   TempDir,
   // Create a temporary directory in the given parent directory.
-  new_in : (fn(parent : Path, io : IO) -> Impl(Future(TempDir, IOErr)))(
+  new_in : (fn(parent : Path, io : Io) -> Impl(Future(TempDir, IoExn)))(
     io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
@@ -62,13 +63,19 @@ impl(
       template_bytes := template_str.as_bytes();
       buf_len := (template_bytes.len() + usize(1));
       buf := *(u8)(malloc(buf_len).unwrap());
-      memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len());
+      // SAFETY: `buf` is a fresh malloc'd `buf_len = template_bytes.len() + 1`
+      // byte buffer; we copy exactly `template_bytes.len()` bytes from
+      // `template_bytes`'s underlying storage (alive for the duration of this
+      // statement — it's the bytes of `template_str` which we own) and write
+      // the trailing NUL at `buf[template_bytes.len()]`. `buf` is freed in
+      // both the error branch and after `IO_temp.mkdtemp` returns.
+      unsafe(memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len()));
       (buf &+ template_bytes.len()).* = u8(0);
       result := IO_temp.mkdtemp(buf);
       cond(
         (result < i32(0)) => {
           free(.Some(*(void)(buf)));
-          e.exn.throw(dyn(IOError.from_errno(i32(0) - result)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - result)));
         },
         true => ()
       );
@@ -78,7 +85,7 @@ impl(
     })
   ),
   // Create a temporary directory in the system temp dir.
-  new : (fn(io : IO) -> Impl(Future(TempDir, IOErr)))(
+  new : (fn(io : Io) -> Impl(Future(TempDir, IoExn)))(
     TempDir.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the path of the temporary directory.
@@ -86,7 +93,7 @@ impl(
     self._path
   ),
   // Remove the temporary directory.
-  remove : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  remove : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     self_path := self._path;
     io.async(
       (e) =>
@@ -110,7 +117,7 @@ TempFile :: object(
 impl(
   TempFile,
   // Create a temporary file in the given parent directory.
-  new_in : (fn(parent : Path, io : IO) -> Impl(Future(TempFile, IOErr)))(
+  new_in : (fn(parent : Path, io : Io) -> Impl(Future(TempFile, IoExn)))(
     io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
@@ -118,13 +125,17 @@ impl(
       template_bytes := template_str.as_bytes();
       buf_len := (template_bytes.len() + usize(1));
       buf := *(u8)(malloc(buf_len).unwrap());
-      memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len());
+      // SAFETY: as in `TempDir.new_in` above — `buf` is a fresh malloc'd
+      // `template_bytes.len() + 1` byte buffer, we copy exactly the template
+      // bytes plus a trailing NUL. `buf` is freed in the error branch and
+      // released to mkstemp's owned-fd lifecycle on success.
+      unsafe(memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len()));
       (buf &+ template_bytes.len()).* = u8(0);
       fd := IO_temp.mkstemp(buf);
       cond(
         (fd < i32(0)) => {
           free(.Some(*(void)(buf)));
-          e.exn.throw(dyn(IOError.from_errno(i32(0) - fd)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - fd)));
         },
         true => ()
       );
@@ -136,7 +147,7 @@ impl(
     })
   ),
   // Create a temporary file in the system temp dir.
-  new : (fn(io : IO) -> Impl(Future(TempFile, IOErr)))(
+  new : (fn(io : Io) -> Impl(Future(TempFile, IoExn)))(
     TempFile.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the underlying File object.
@@ -148,7 +159,7 @@ impl(
     self._path
   ),
   // Remove the temporary file.
-  remove : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  remove : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     self_file := self._file;
     self_path := self._path;
     io.async(

package/std/fs/walker.yo

@@ -5,21 +5,22 @@
 //! ```rust
 //! { walk, WalkEntry } :: import "std/fs/walker";
 //!
-//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
 //!   entries := io.await(walk(Path.new(`/tmp`), io), { io, exn });
 //!   i := usize(0);
 //!   while runtime((i < entries.len())), {
-//!     e := entries.get(i).unwrap();
+//!     e := entries(i);
 //!     println(e.path);
 //!     i = (i + usize(1));
 //!   };
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../collections/array_list");
 open(import("../string"));
 { Path } :: import("../path");
-{ IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ IoError } :: import("../sys/errors");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 { FileType } :: import("./dir");
 { DirEntry } :: import("./dir");
 _dir :: import("./dir");
@@ -61,7 +62,7 @@ _join_path :: (fn(base : String, name : String) -> String)(
 // Walk functions
 // ============================================================================
 // Walk a directory tree with custom options.
-walk_with :: (fn(root : Path, options : WalkOptions, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))({
+walk_with :: (fn(root : Path, options : WalkOptions, io : Io) -> Impl(Future(ArrayList(WalkEntry), IoExn)))({
   root_s := root.to_string();
   io.async((e) => {
     results := ArrayList(WalkEntry).new();
@@ -83,7 +84,7 @@ walk_with :: (fn(root : Path, options : WalkOptions, io : IO) -> Impl(Future(Arr
           entries := e.io.await(_dir.read_dir(Path.new(cur_path), e.io), e);
           i := usize(0);
           while(runtime(i < entries.len()), {
-            entry := entries.get(i).unwrap();
+            entry := entries(i);
             entry_path := _join_path(cur_path, entry.name);
             match(
               entry.file_type,
@@ -124,10 +125,10 @@ walk_with :: (fn(root : Path, options : WalkOptions, io : IO) -> Impl(Future(Arr
     results
   })
 });
-walk_with_cstr :: (fn(root : *(u8), options : WalkOptions, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(
+walk_with_cstr :: (fn(root : *(u8), options : WalkOptions, io : Io) -> Impl(Future(ArrayList(WalkEntry), IoExn)))(
   walk_with(Path.from_cstr(root), options, io)
 );
 /// Walk a directory tree with default options.
-walk :: (fn(root : Path, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(walk_with(root, WalkOptions.defaults(), io));
-walk_cstr :: (fn(root : *(u8), io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(walk(Path.from_cstr(root), io));
+walk :: (fn(root : Path, io : Io) -> Impl(Future(ArrayList(WalkEntry), IoExn)))(walk_with(root, WalkOptions.defaults(), io));
+walk_cstr :: (fn(root : *(u8), io : Io) -> Impl(Future(ArrayList(WalkEntry), IoExn)))(walk(Path.from_cstr(root), io));
 export(walk, walk_cstr, walk_with, walk_with_cstr);

package/std/gc.yo

@@ -1,4 +1,5 @@
 //! Garbage collection interface for cycle collection.
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_gc_collect : (fn() -> unit),