Add runnable Csv 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)`, `Assert.equal(left: read String, right: read String)`, and the core `File` and `Json` 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.
+The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, and the core `File`, `Json`, and `Csv` 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:
 

core/csv/csv.rssi

@@ -0,0 +1,17 @@
+struct RowBuffer
+
+struct Row
+
+pub fn RowBuffer.new(size: Int) -> fresh RowBuffer
+
+pub fn Csv.read_into(
+    file: mut File,
+    buffer: mut RowBuffer,
+) -> Result<Unit, CsvError>
+
+pub fn Csv.parse_row(buffer: read RowBuffer) -> Result<fresh Row, CsvError>
+
+pub fn Row.field_string(
+    row: read Row,
+    index: Int,
+) -> Result<String, CsvError>

core/prototype/builtins.rssi

@@ -6,15 +6,6 @@ pub fn ImageCache.store(
 ) -> Unit
     effects(retains(image))
 
-pub fn RowBuffer.new(size: Int) -> fresh RowBuffer
-
-pub fn Csv.read_into(
-    file: mut File,
-    buffer: mut RowBuffer,
-) -> Result<Unit, CsvError>
-
-pub fn Csv.parse_row(buffer: read RowBuffer) -> Result<fresh Row, CsvError>
-
 pub fn List.consume(list: take List) -> Unit
 
 pub fn Buffer.consume(buffer: take Buffer) -> Unit

examples/csv_read.rss

@@ -0,0 +1,20 @@
+features: local
+
+fn main() -> Result<Unit, CsvError> {
+    let path = "rsscript-csv-example.csv"
+
+    with File.open_write(path: read path) as file {
+        File.write(file: mut file, data: read "name,amount\nRSScript,42\n")?
+    }
+
+    local buffer = RowBuffer.new(size: 4096)
+    with File.open_read(path: read path) as file {
+        Csv.read_into(file: mut file, buffer: mut buffer)?
+        let row = Csv.parse_row(buffer: read buffer)?
+        let name = Row.field_string(row: read row, index: 0)?
+        Assert.equal(left: read name, right: read "RSScript")
+        Log.write(message: read name)
+    }
+
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -4,6 +4,7 @@ use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
 use std::rc::Rc;
+use std::str::Utf8Error;
 
 pub trait Managed {}
 
@@ -49,6 +50,49 @@ impl From<serde_json::Error> for JsonError {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct RowBuffer {
+    bytes: Vec<u8>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Row {
+    fields: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CsvError {
+    message: String,
+}
+
+impl CsvError {
+    fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl fmt::Display for CsvError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}", self.message)
+    }
+}
+
+impl std::error::Error for CsvError {}
+
+impl From<std::io::Error> for CsvError {
+    fn from(error: std::io::Error) -> Self {
+        Self::new(error.to_string())
+    }
+}
+
+impl From<Utf8Error> for CsvError {
+    fn from(error: Utf8Error) -> Self {
+        Self::new(error.to_string())
+    }
+}
+
 pub trait RuntimePath {
     fn as_path(&self) -> &std::path::Path;
 }
@@ -152,6 +196,45 @@ pub fn json_field_string(value: &JsonValue, name: &str) -> Result<String, JsonEr
     Ok(text.to_string())
 }
 
+pub fn row_buffer_new(size: i64) -> RowBuffer {
+    RowBuffer {
+        bytes: Vec::with_capacity(size.max(0) as usize),
+    }
+}
+
+pub fn csv_read_into(file: &mut File, buffer: &mut RowBuffer) -> Result<(), CsvError> {
+    buffer.bytes.clear();
+    file.inner.read_to_end(&mut buffer.bytes)?;
+    Ok(())
+}
+
+pub fn csv_parse_row(buffer: &RowBuffer) -> Result<Row, CsvError> {
+    let text = std::str::from_utf8(&buffer.bytes)?;
+    let Some(line) = text
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .nth(1)
+        .or_else(|| text.lines().map(str::trim).find(|line| !line.is_empty()))
+    else {
+        return Err(CsvError::new("CSV buffer is empty"));
+    };
+    Ok(Row {
+        fields: line
+            .split(',')
+            .map(|field| field.trim().to_string())
+            .collect(),
+    })
+}
+
+pub fn row_field_string(row: &Row, index: i64) -> Result<String, CsvError> {
+    let index = usize::try_from(index).map_err(|_| CsvError::new("negative CSV field index"))?;
+    row.fields
+        .get(index)
+        .cloned()
+        .ok_or_else(|| CsvError::new(format!("CSV field index `{index}` is out of bounds")))
+}
+
 #[derive(Clone)]
 pub struct Gc<T> {
     inner: Rc<RefCell<T>>,
@@ -536,4 +619,25 @@ mod tests {
 
         assert_eq!(name, "RSScript");
     }
+
+    #[test]
+    fn csv_runtime_hooks_read_and_parse_row() {
+        let path =
+            std::env::temp_dir().join(format!("rsscript-runtime-csv-{}.csv", std::process::id()));
+
+        {
+            let mut file = super::file_open_write(&path).expect("file should open for write");
+            super::file_write(&mut file, &"name,amount\nRSScript,42\n")
+                .expect("write should succeed");
+        }
+
+        let mut file = super::file_open_read(&path).expect("file should open for read");
+        let mut buffer = super::row_buffer_new(4096);
+        super::csv_read_into(&mut file, &mut buffer).expect("CSV read should succeed");
+        let row = super::csv_parse_row(&buffer).expect("CSV row should parse");
+        let name = super::row_field_string(&row, 0).expect("field should exist");
+
+        assert_eq!(name, "RSScript");
+        let _ = std::fs::remove_file(path);
+    }
 }

src/interfaces.rs

@@ -3,6 +3,7 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         "core/collections/map.rssi",
         include_str!("../core/collections/map.rssi"),
     ),
+    ("core/csv/csv.rssi", include_str!("../core/csv/csv.rssi")),
     ("core/fs/file.rssi", include_str!("../core/fs/file.rssi")),
     (
         "core/image/image.rssi",

src/rust_lower.rs

@@ -785,6 +785,9 @@ impl<'a> RustLowerer<'a> {
             "FileError" | "IOError" => "std::io::Error".to_string(),
             "JsonValue" => "rsscript_runtime::JsonValue".to_string(),
             "JsonError" => "rsscript_runtime::JsonError".to_string(),
+            "RowBuffer" => "rsscript_runtime::RowBuffer".to_string(),
+            "Row" => "rsscript_runtime::Row".to_string(),
+            "CsvError" => "rsscript_runtime::CsvError".to_string(),
             "Result" if ty.args.len() == 2 => format!(
                 "Result<{}, {}>",
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested),
@@ -1066,6 +1069,14 @@ fn lower_callee(callee: &Callee) -> String {
         callee if is_json_field_string_callee(callee) => {
             "rsscript_runtime::json_field_string".to_string()
         }
+        callee if is_row_buffer_new_callee(callee) => {
+            "rsscript_runtime::row_buffer_new".to_string()
+        }
+        callee if is_csv_read_into_callee(callee) => "rsscript_runtime::csv_read_into".to_string(),
+        callee if is_csv_parse_row_callee(callee) => "rsscript_runtime::csv_parse_row".to_string(),
+        callee if is_row_field_string_callee(callee) => {
+            "rsscript_runtime::row_field_string".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))
@@ -1120,6 +1131,22 @@ fn is_json_field_string_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Json" && name == "field_string")
 }
 
+fn is_row_buffer_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "RowBuffer" && name == "new")
+}
+
+fn is_csv_read_into_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Csv" && name == "read_into")
+}
+
+fn is_csv_parse_row_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Csv" && name == "parse_row")
+}
+
+fn is_row_field_string_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Row" && name == "field_string")
+}
+
 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))
 }

tests/checker.rs

@@ -356,6 +356,29 @@ fn read_name(text: read String) -> Result<String, JsonError> {
     );
 }
 
+#[test]
+fn rust_lowering_maps_csv_core_calls_to_runtime_hooks() {
+    let source = r#"
+features: local
+
+fn read_name(path: read Path) -> Result<String, CsvError> {
+    local buffer = RowBuffer.new(size: 4096)
+    with File.open_read(path: read path) as file {
+        Csv.read_into(file: mut file, buffer: mut buffer)?
+        let row = Csv.parse_row(buffer: read buffer)?
+        return Row.field_string(row: read row, index: 0)
+    }
+}
+"#;
+    let rust = lower_source_to_rust("csv.rss", source).expect("source should lower");
+
+    assert!(rust.contains("-> Result<String, rsscript_runtime::CsvError>"));
+    assert!(rust.contains("let mut buffer = rsscript_runtime::row_buffer_new(4096);"));
+    assert!(rust.contains("rsscript_runtime::csv_read_into(&mut file, &mut buffer)?;"));
+    assert!(rust.contains("let row = rsscript_runtime::csv_parse_row(&buffer)?;"));
+    assert!(rust.contains("return rsscript_runtime::row_field_string(&row, 0);"));
+}
+
 #[test]
 fn rust_lowering_decodes_string_escape_sequences() {
     let source = r#"