Merge branch 'main' into replace-glue

Author: smores56

.github/workflows/ci.yml

@@ -16,6 +16,9 @@ jobs:
         operating-system: [ubuntu-20.04, ubuntu-22.04]
     steps:
       - uses: actions/checkout@v3
+
+      - name: Does init() in platform/src/lib.rs contain all roc_fx functions? (Imperfect check)
+        run: cat platform/src/lib.rs | grep -oP 'roc_fx_[^(\s]*' | sort | uniq -u | grep -q . && exit 1 || exit 0
 
       - id: try_fetching_testing_release
         continue-on-error: true

flake.lock

@@ -10,7 +10,6 @@
     rust-overlay = {
       url = "github:oxalica/rust-overlay";
       inputs.nixpkgs.follows = "nixpkgs";
-      inputs.flake-utils.follows = "flake-utils";
     };
     # to easily make configs for multiple architectures
     flake-utils.url = "github:numtide/flake-utils";

flake.nix

@@ -1,5 +1,5 @@
 #![allow(non_snake_case)]
-
+#![allow(improper_ctypes)]
 use core::alloc::Layout;
 use core::ffi::c_void;
 use core::mem::MaybeUninit;
@@ -54,16 +54,19 @@ extern "C" {
     #[allow(dead_code)]
     #[link_name = "roc__mainForHost_0_size"]
     fn size_Fx() -> i64;
-
-    #[link_name = "roc__mainForHost_0_result_size"]
-    fn size_Fx_result() -> i64;
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[no_mangle]
 pub unsafe extern "C" fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void {
     libc::malloc(size)
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[no_mangle]
 pub unsafe extern "C" fn roc_realloc(
     c_ptr: *mut c_void,
@@ -74,11 +77,17 @@ pub unsafe extern "C" fn roc_realloc(
     libc::realloc(c_ptr, new_size)
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[no_mangle]
 pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
     libc::free(c_ptr)
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[no_mangle]
 pub unsafe extern "C" fn roc_panic(msg: &RocStr, tag_id: u32) {
     _ = crossterm::terminal::disable_raw_mode();
@@ -99,17 +108,26 @@ pub unsafe extern "C" fn roc_panic(msg: &RocStr, tag_id: u32) {
     }
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[no_mangle]
 pub unsafe extern "C" fn roc_dbg(loc: &RocStr, msg: &RocStr, src: &RocStr) {
     eprintln!("[{}] {} = {}", loc, src, msg);
 }
 
+/// # Safety
+///
+/// This function is unsafe.
 #[cfg(unix)]
 #[no_mangle]
 pub unsafe extern "C" fn roc_getppid() -> libc::pid_t {
     libc::getppid()
 }
 
+/// # Safety
+///
+/// This function should be called with a valid addr pointer.
 #[cfg(unix)]
 #[no_mangle]
 pub unsafe extern "C" fn roc_mmap(
@@ -123,6 +141,9 @@ pub unsafe extern "C" fn roc_mmap(
     libc::mmap(addr, len, prot, flags, fd, offset)
 }
 
+/// # Safety
+///
+/// This function should be called with a valid name pointer.
 #[cfg(unix)]
 #[no_mangle]
 pub unsafe extern "C" fn roc_shm_open(
@@ -152,9 +173,10 @@ fn print_backtrace() {
                 let fn_name = fn_name.to_string();
 
                 if should_show_in_backtrace(&fn_name) {
-                    let mut entry: Entry = Default::default();
-
-                    entry.fn_name = format_fn_name(&fn_name);
+                    let mut entry = Entry {
+                        fn_name: format_fn_name(&fn_name),
+                        ..Default::default()
+                    };
 
                     if let Some(path) = symbol.filename() {
                         entry.filename = Some(path.to_string_lossy().into_owned());
@@ -201,7 +223,7 @@ fn should_show_in_backtrace(fn_name: &str) -> bool {
 fn format_fn_name(fn_name: &str) -> String {
     // e.g. convert "_Num_sub_a0c29024d3ec6e3a16e414af99885fbb44fa6182331a70ab4ca0886f93bad5"
     // to ["Num", "sub", "a0c29024d3ec6e3a16e414af99885fbb44fa6182331a70ab4ca0886f93bad5"]
-    let mut pieces_iter = fn_name.split("_");
+    let mut pieces_iter = fn_name.split('_');
 
     if let (_, Some(module_name), Some(name)) =
         (pieces_iter.next(), pieces_iter.next(), pieces_iter.next())
@@ -228,6 +250,9 @@ fn display_roc_fn(module_name: &str, fn_name: &str) -> String {
     format!("\u{001B}[36m{module_name}\u{001B}[39m.{fn_name}")
 }
 
+/// # Safety
+///
+/// This function should be provided a valid dst pointer.
 #[no_mangle]
 pub unsafe extern "C" fn roc_memset(dst: *mut c_void, c: i32, n: usize) -> *mut c_void {
     libc::memset(dst, c, n)
@@ -259,7 +284,11 @@ pub fn init() {
         roc_fx_ttyModeRaw as _,
         roc_fx_fileWriteUtf8 as _,
         roc_fx_fileWriteBytes as _,
+        roc_fx_pathType as _,
         roc_fx_fileReadBytes as _,
+        roc_fx_fileReader as _,
+        roc_fx_fileReadLine as _,
+        roc_fx_closeFile as _,
         roc_fx_fileDelete as _,
         roc_fx_cwd as _,
         roc_fx_posixTime as _,
@@ -278,7 +307,7 @@ pub fn init() {
         roc_fx_dirCreateAll as _,
         roc_fx_dirDeleteEmpty as _,
         roc_fx_dirDeleteAll as _,
-        roc_fx_pathType as _,
+        roc_fx_currentArchOS as _,
     ];
     #[allow(forgetting_references)]
     std::mem::forget(std::hint::black_box(funcs));
@@ -305,10 +334,13 @@ pub extern "C" fn rust_main() -> i32 {
 
         std::alloc::dealloc(buffer, layout);
 
-        return out;
+        out
     }
 }
 
+/// # Safety
+///
+/// This function should be passed a pointer to a closure data buffer.
 pub unsafe fn call_the_closure(closure_data_ptr: *const u8) -> i32 {
     // Main always returns an i32. just allocate for that.
     let mut out: RocResult<(), i32> = RocResult::ok(());
@@ -381,7 +413,7 @@ fn handleStdinErr(io_err: std::io::Error) -> RocStr {
         ErrorKind::OutOfMemory => "ErrorKind::OutOfMemory".into(),
         ErrorKind::Interrupted => "ErrorKind::Interrupted".into(),
         ErrorKind::Unsupported => "ErrorKind::Unsupported".into(),
-        _ => RocStr::from(RocStr::from(format!("{:?}", io_err).as_str())),
+        _ => format!("{:?}", io_err).as_str().into(),
     }
 }
 
@@ -403,20 +435,20 @@ pub extern "C" fn roc_fx_stdinBytes() -> RocList<u8> {
 
     match stdin.lock().read(&mut buffer) {
         Ok(bytes_read) => RocList::from(&buffer[0..bytes_read]),
-        Err(_) => RocList::from((&[]).as_slice()),
+        Err(_) => RocList::from(([]).as_slice()),
     }
 }
 
 /// See docs in `platform/Stdout.roc` for descriptions
 fn handleStdoutErr(io_err: std::io::Error) -> RocStr {
     match io_err.kind() {
-        ErrorKind::BrokenPipe => RocStr::from("ErrorKind::BrokenPipe"),
-        ErrorKind::WouldBlock => RocStr::from("ErrorKind::WouldBlock"),
-        ErrorKind::WriteZero => RocStr::from("ErrorKind::WriteZero"),
-        ErrorKind::Unsupported => RocStr::from("ErrorKind::Unsupported"),
-        ErrorKind::Interrupted => RocStr::from("ErrorKind::Interrupted"),
-        ErrorKind::OutOfMemory => RocStr::from("ErrorKind::OutOfMemory"),
-        _ => RocStr::from(RocStr::from(format!("{:?}", io_err).as_str())),
+        ErrorKind::BrokenPipe => "ErrorKind::BrokenPipe".into(),
+        ErrorKind::WouldBlock => "ErrorKind::WouldBlock".into(),
+        ErrorKind::WriteZero => "ErrorKind::WriteZero".into(),
+        ErrorKind::Unsupported => "ErrorKind::Unsupported".into(),
+        ErrorKind::Interrupted => "ErrorKind::Interrupted".into(),
+        ErrorKind::OutOfMemory => "ErrorKind::OutOfMemory".into(),
+        _ => format!("{:?}", io_err).as_str().into(),
     }
 }
 
@@ -450,13 +482,13 @@ pub extern "C" fn roc_fx_stdoutWrite(text: &RocStr) -> RocResult<(), RocStr> {
 /// See docs in `platform/Stdout.roc` for descriptions
 fn handleStderrErr(io_err: std::io::Error) -> RocStr {
     match io_err.kind() {
-        ErrorKind::BrokenPipe => RocStr::from("ErrorKind::BrokenPipe"),
-        ErrorKind::WouldBlock => RocStr::from("ErrorKind::WouldBlock"),
-        ErrorKind::WriteZero => RocStr::from("ErrorKind::WriteZero"),
-        ErrorKind::Unsupported => RocStr::from("ErrorKind::Unsupported"),
-        ErrorKind::Interrupted => RocStr::from("ErrorKind::Interrupted"),
-        ErrorKind::OutOfMemory => RocStr::from("ErrorKind::OutOfMemory"),
-        _ => RocStr::from(RocStr::from(format!("{:?}", io_err).as_str())),
+        ErrorKind::BrokenPipe => "ErrorKind::BrokenPipe".into(),
+        ErrorKind::WouldBlock => "ErrorKind::WouldBlock".into(),
+        ErrorKind::WriteZero => "ErrorKind::WriteZero".into(),
+        ErrorKind::Unsupported => "ErrorKind::Unsupported".into(),
+        ErrorKind::Interrupted => "ErrorKind::Interrupted".into(),
+        ErrorKind::OutOfMemory => "ErrorKind::OutOfMemory".into(),
+        _ => format!("{:?}", io_err).as_str().into(),
     }
 }
 
@@ -683,20 +715,15 @@ pub extern "C" fn roc_fx_dirList(
 
         let mut entries = Vec::new();
 
-        for entry in dir {
-            match entry {
-                Ok(entry) => {
-                    let path = entry.path();
-                    let str = path.as_os_str();
-                    entries.push(os_str_to_roc_path(str));
-                }
-                Err(_) => {} // TODO should we ignore errors reading directory??
-            }
+        for entry in dir.flatten() {
+            let path = entry.path();
+            let str = path.as_os_str();
+            entries.push(os_str_to_roc_path(str));
         }
 
-        return RocResult::ok(RocList::from_iter(entries));
+        RocResult::ok(RocList::from_iter(entries))
     } else {
-        return RocResult::err("ErrorKind::NotADirectory".into());
+        RocResult::err("ErrorKind::NotADirectory".into())
     }
 }
 
@@ -717,7 +744,6 @@ fn os_str_to_roc_path(os_str: &OsStr) -> RocList<u8> {
 }
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct Request {
     body: RocList<u8>,
     headers: RocList<Header>,
@@ -728,14 +754,12 @@ pub struct Request {
 }
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct Header {
     key: RocStr,
     value: RocStr,
 }
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct Metadata {
     headers: RocList<Header>,
     url: RocStr,
@@ -755,7 +779,6 @@ impl Metadata {
 }
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct InternalResponse {
     body: RocList<u8>,
     metadata: Metadata,
@@ -822,7 +845,7 @@ pub extern "C" fn roc_fx_sendRequest(roc_request: &Request) -> InternalResponse
     let bytes = String::from_utf8(roc_request.body.as_slice().to_vec()).unwrap();
     let mime_type_str = roc_request.mimeType.as_str();
 
-    if !has_content_type_header && mime_type_str.len() > 0 {
+    if !has_content_type_header && !mime_type_str.is_empty() {
         req_builder = req_builder.header("Content-Type", mime_type_str);
     }
 
@@ -1024,7 +1047,6 @@ pub extern "C" fn roc_fx_tcpReadExactly(
             Err(err) => RocResult::err(to_tcp_stream_err(err)),
         }
     })
-
 }
 
 #[no_mangle]
@@ -1090,7 +1112,6 @@ fn to_tcp_stream_err(err: std::io::Error) -> RocStr {
 }
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct Command {
     pub args: RocList<RocStr>,
     pub envs: RocList<RocStr>,
@@ -1282,7 +1303,7 @@ fn handleDirError(io_err: std::io::Error) -> RocStr {
         // ErrorKind::FilesystemQuotaExceeded => RocStr::from("ErrorKind::FilesystemQuotaExceeded"),
         // ErrorKind::StorageFull => RocStr::from("ErrorKind::StorageFull"),
         // ErrorKind::InvalidFilename => RocStr::from("ErrorKind::InvalidFilename"),
-        _ => RocStr::from(RocStr::from(format!("{:?}", io_err).as_str())),
+        _ => RocStr::from(format!("{:?}", io_err).as_str()),
     }
 }