Add runnable File runtime hooks

Author: olwang

README.md

@@ -418,7 +418,7 @@ If a lowered package contains `fn main() -> Unit` or `fn main() -> Result<Unit,
 
 `rss verify-rust <file.rss> --out-dir <directory>` keeps the generated package used for backend checking, including `rsscript-source-map.json`, so unmappable rustc diagnostics can be inspected against the generated Rust.
 
-The first observable runtime boundaries are `Log.write(message: read String)` and `Assert.equal(left: read String, right: read String)`, which lower to explicit runtime hooks. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
+The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, and the core `File` APIs, which lower to explicit runtime hooks. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
 
 Smallest runnable example:
 

examples/file_copy.rss

@@ -0,0 +1,28 @@
+pub fn copy_file(input: read Path, output: read Path) -> Result<Unit, IOError> {
+    with File.open_read(path: read input) as reader {
+        with File.open_write(path: read output) as writer {
+            let bytes = File.read_all(file: mut reader)?
+            File.write(file: mut writer, data: read bytes)?
+        }
+    }
+    return Ok(Unit)
+}
+
+fn main() -> Result<Unit, IOError> {
+    let input = "rsscript-file-copy-input.txt"
+    let output = "rsscript-file-copy-output.txt"
+
+    with File.open_write(path: read input) as file {
+        File.write(file: mut file, data: read "file copy ran")?
+    }
+
+    with File.open_read(path: read input) as reader {
+        with File.open_write(path: read output) as writer {
+            let bytes = File.read_all(file: mut reader)?
+            File.write(file: mut writer, data: read bytes)?
+        }
+    }
+
+    Log.write(message: read "file copy ran")
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -1,6 +1,8 @@
 use std::cell::{BorrowError, BorrowMutError, Ref, RefCell, RefMut};
 use std::fmt;
+use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
+use std::path::PathBuf;
 use std::rc::Rc;
 
 pub trait Managed {}
@@ -9,6 +11,90 @@ impl<T: 'static> Managed for T {}
 
 pub trait Resource {}
 
+pub struct File {
+    inner: std::fs::File,
+}
+
+impl Resource for File {}
+
+pub trait RuntimePath {
+    fn as_path(&self) -> &std::path::Path;
+}
+
+impl RuntimePath for PathBuf {
+    fn as_path(&self) -> &std::path::Path {
+        self.as_path()
+    }
+}
+
+impl RuntimePath for String {
+    fn as_path(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl RuntimePath for str {
+    fn as_path(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl<T: RuntimePath + ?Sized> RuntimePath for &T {
+    fn as_path(&self) -> &std::path::Path {
+        (*self).as_path()
+    }
+}
+
+pub trait RuntimeBytes {
+    fn as_bytes_slice(&self) -> &[u8];
+}
+
+impl RuntimeBytes for Vec<u8> {
+    fn as_bytes_slice(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+impl RuntimeBytes for String {
+    fn as_bytes_slice(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl RuntimeBytes for str {
+    fn as_bytes_slice(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl<T: RuntimeBytes + ?Sized> RuntimeBytes for &T {
+    fn as_bytes_slice(&self) -> &[u8] {
+        (*self).as_bytes_slice()
+    }
+}
+
+pub fn file_open<P: RuntimePath + ?Sized>(path: &P) -> std::io::Result<File> {
+    file_open_read(path)
+}
+
+pub fn file_open_read<P: RuntimePath + ?Sized>(path: &P) -> std::io::Result<File> {
+    std::fs::File::open(path.as_path()).map(|inner| File { inner })
+}
+
+pub fn file_open_write<P: RuntimePath + ?Sized>(path: &P) -> std::io::Result<File> {
+    std::fs::File::create(path.as_path()).map(|inner| File { inner })
+}
+
+pub fn file_read_all(file: &mut File) -> std::io::Result<Vec<u8>> {
+    let mut bytes = Vec::new();
+    file.inner.read_to_end(&mut bytes)?;
+    Ok(bytes)
+}
+
+pub fn file_write<B: RuntimeBytes + ?Sized>(file: &mut File, data: &B) -> std::io::Result<()> {
+    file.inner.write_all(data.as_bytes_slice())
+}
+
 #[derive(Clone)]
 pub struct Gc<T> {
     inner: Rc<RefCell<T>>,
@@ -365,4 +451,21 @@ mod tests {
 
         assert_eq!(error.kind, RuntimeErrorKind::ResourcePoolBorrowConflict);
     }
+
+    #[test]
+    fn file_runtime_hooks_write_and_read_bytes() {
+        let path =
+            std::env::temp_dir().join(format!("rsscript-runtime-file-{}.txt", std::process::id()));
+
+        {
+            let mut file = super::file_open_write(&path).expect("file should open for write");
+            super::file_write(&mut file, &"hello file").expect("write should succeed");
+        }
+
+        let mut file = super::file_open_read(&path).expect("file should open for read");
+        let bytes = super::file_read_all(&mut file).expect("read should succeed");
+
+        assert_eq!(bytes, b"hello file");
+        let _ = std::fs::remove_file(path);
+    }
 }

src/rust_lower.rs

@@ -496,6 +496,8 @@ impl<'a> RustLowerer<'a> {
                 let resource = self.lower_expr(&stmt.resource);
                 let resource = if is_resource_pool_borrow_expr(&stmt.resource) {
                     format!("rsscript_runtime::unwrap_runtime({resource})")
+                } else if is_file_open_expr(&stmt.resource) {
+                    format!("{resource}?")
                 } else {
                     resource
                 };
@@ -779,6 +781,8 @@ impl<'a> RustLowerer<'a> {
             "String" => "String".to_string(),
             "Bytes" | "Buffer" => "Vec<u8>".to_string(),
             "Path" => "std::path::PathBuf".to_string(),
+            "File" => "rsscript_runtime::File".to_string(),
+            "FileError" | "IOError" => "std::io::Error".to_string(),
             "Result" if ty.args.len() == 2 => format!(
                 "Result<{}, {}>",
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested),
@@ -1046,6 +1050,15 @@ fn lower_callee(callee: &Callee) -> String {
     match callee {
         callee if is_log_write_callee(callee) => "rsscript_runtime::log_write".to_string(),
         callee if is_assert_equal_callee(callee) => "rsscript_runtime::assert_equal".to_string(),
+        callee if is_file_open_callee(callee) => "rsscript_runtime::file_open".to_string(),
+        callee if is_file_open_read_callee(callee) => {
+            "rsscript_runtime::file_open_read".to_string()
+        }
+        callee if is_file_open_write_callee(callee) => {
+            "rsscript_runtime::file_open_write".to_string()
+        }
+        callee if is_file_read_all_callee(callee) => "rsscript_runtime::file_read_all".to_string(),
+        callee if is_file_write_callee(callee) => "rsscript_runtime::file_write".to_string(),
         Callee::Name(name) => rust_ident(name),
         Callee::Qualified { namespace, name } if type_root_name(namespace) == "ResourcePool" => {
             format!("rsscript_runtime::ResourcePool::{}", rust_ident(name))
@@ -1068,6 +1081,30 @@ fn is_string_concat_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "String" && name == "concat")
 }
 
+fn is_file_open_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "open")
+}
+
+fn is_file_open_read_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "open_read")
+}
+
+fn is_file_open_write_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "open_write")
+}
+
+fn is_file_read_all_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "read_all")
+}
+
+fn is_file_write_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "write")
+}
+
+fn is_file_open_expr(expr: &Expr) -> bool {
+    matches!(expr, Expr::Call { callee, .. } if is_file_open_callee(callee) || is_file_open_read_callee(callee) || is_file_open_write_callee(callee))
+}
+
 fn lower_string_concat_call(lowerer: &mut RustLowerer<'_>, args: &[CallArg]) -> String {
     let left = lower_call_arg(lowerer, args, "left", 0, "\"\".to_string()");
     let right = lower_call_arg(lowerer, args, "right", 1, "\"\".to_string()");

tests/checker.rs

@@ -311,6 +311,28 @@ pub fn inspect_core(
     assert!(rust.contains("-> Result<Vec<u8>, CoreError>"));
 }
 
+#[test]
+fn rust_lowering_maps_file_core_calls_to_runtime_hooks() {
+    let source = r#"
+fn copy_file(input: read Path, output: read Path) -> Result<Unit, IOError> {
+    with File.open_read(path: read input) as reader {
+        with File.open_write(path: read output) as writer {
+            let bytes = File.read_all(file: mut reader)?
+            File.write(file: mut writer, data: read bytes)?
+        }
+    }
+    return Ok(Unit)
+}
+"#;
+    let rust = lower_source_to_rust("file.rss", source).expect("source should lower");
+
+    assert!(rust.contains("-> Result<(), std::io::Error>"));
+    assert!(rust.contains("let mut reader = rsscript_runtime::file_open_read(&input)?;"));
+    assert!(rust.contains("let mut writer = rsscript_runtime::file_open_write(&output)?;"));
+    assert!(rust.contains("let bytes = rsscript_runtime::file_read_all(&mut reader)?;"));
+    assert!(rust.contains("rsscript_runtime::file_write(&mut writer, &bytes)?;"));
+}
+
 #[test]
 fn rust_lowering_maps_log_write_to_runtime_output_hook() {
     let source = r#"