Add runnable take consume 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`, `Json`, `Csv`, `Image`, `ImageCache`, HTTP handler, DB resource-pool, config reload, interpreter object-cycle, and `Counter` APIs, which lower to explicit runtime hooks. `ImageCache` is the first small retained managed-container hook: it stores managed image handles and enforces a capacity limit. The interpreter hooks model `Environment` and `FunctionObject` as managed handles, including an environment/function closure cycle. 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)`, `OS.close(fd: Fd)`, `List.consume(list: take List<T>)`, `Buffer.consume(buffer: take Buffer)`, and the core `File`, `Json`, `Csv`, `Image`, `ImageCache`, HTTP handler, DB resource-pool, config reload, interpreter object-cycle, and `Counter` APIs, which lower to explicit runtime hooks. `ImageCache` is the first small retained managed-container hook: it stores managed image handles and enforces a capacity limit. The interpreter hooks model `Environment` and `FunctionObject` as managed handles, including an environment/function closure cycle. 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/collections/buffer.rssi

@@ -0,0 +1 @@
+pub fn Buffer.consume(buffer: take Buffer) -> Unit

core/collections/list.rssi

@@ -0,0 +1 @@
+pub fn List.consume<T>(list: take List<T>) -> Unit

core/os/os.rssi

@@ -0,0 +1 @@
+pub fn OS.close(fd: Fd) -> Unit

core/prototype/builtins.rssi

@@ -1,9 +1,3 @@
-pub fn OS.close(fd: Fd) -> Unit
-
-pub fn List.consume(list: take List) -> Unit
-
-pub fn Buffer.consume(buffer: take Buffer) -> Unit
-
 pub fn RuleLoader.load_rules(path: read Path) -> Result<fresh List<Rule>, ConfigError>
 
 pub fn GlobalConfig.replace(

examples/buffer_consume.rss

@@ -0,0 +1,18 @@
+features: local
+
+fn main() -> Result<Unit, FileError> {
+    let path = "rsscript-buffer-consume.txt"
+
+    with File.open_write(path: read path) as file {
+        File.write(file: mut file, data: read "consume buffer")?
+    }
+
+    with File.open_read(path: read path) as file {
+        local bytes = File.read_all(file: mut file)?
+        Buffer.consume(buffer: take bytes)
+    }
+
+    OS.close(fd: 0)
+    Log.write(message: read "buffer consumed")
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -355,6 +355,18 @@ pub fn file_write<B: RuntimeBytes + ?Sized>(file: &mut File, data: &B) -> std::i
     file.inner.write_all(data.as_bytes_slice())
 }
 
+pub fn os_close(fd: i64) {
+    let _ = fd;
+}
+
+pub fn list_consume<T>(list: Vec<T>) {
+    drop(list);
+}
+
+pub fn buffer_consume(buffer: Vec<u8>) {
+    drop(buffer);
+}
+
 pub fn request_new(path: &str) -> Request {
     Request {
         path: path.to_string(),
@@ -1049,6 +1061,13 @@ mod tests {
         assert_eq!(super::counter_value(&counter), 3);
     }
 
+    #[test]
+    fn consume_runtime_hooks_take_collections() {
+        super::list_consume(vec![1_i64, 2, 3]);
+        super::buffer_consume(b"bytes".to_vec());
+        super::os_close(0);
+    }
+
     #[test]
     fn interpreter_runtime_hooks_link_environment_function_cycle() {
         let root = super::manage(super::environment_root());

src/interfaces.rs

@@ -3,6 +3,14 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         "core/cache/image_cache.rssi",
         include_str!("../core/cache/image_cache.rssi"),
     ),
+    (
+        "core/collections/buffer.rssi",
+        include_str!("../core/collections/buffer.rssi"),
+    ),
+    (
+        "core/collections/list.rssi",
+        include_str!("../core/collections/list.rssi"),
+    ),
     (
         "core/collections/map.rssi",
         include_str!("../core/collections/map.rssi"),
@@ -35,6 +43,7 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         include_str!("../core/json/json.rssi"),
     ),
     ("core/log/log.rssi", include_str!("../core/log/log.rssi")),
+    ("core/os/os.rssi", include_str!("../core/os/os.rssi")),
     (
         "core/resource/resource_pool.rssi",
         include_str!("../core/resource/resource_pool.rssi"),

src/rust_lower.rs

@@ -1185,6 +1185,11 @@ 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_os_close_callee(callee) => "rsscript_runtime::os_close".to_string(),
+        callee if is_list_consume_callee(callee) => "rsscript_runtime::list_consume".to_string(),
+        callee if is_buffer_consume_callee(callee) => {
+            "rsscript_runtime::buffer_consume".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()
@@ -1291,6 +1296,18 @@ fn is_assert_equal_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Assert" && name == "equal")
 }
 
+fn is_os_close_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "OS" && name == "close")
+}
+
+fn is_list_consume_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "List" && name == "consume")
+}
+
+fn is_buffer_consume_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Buffer" && name == "consume")
+}
+
 fn is_string_concat_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "String" && name == "concat")
 }

tests/checker.rs

@@ -87,6 +87,21 @@ fn bundled_core_interfaces_are_available_to_checker() {
             .iter()
             .any(|(path, _)| *path == "core/log/log.rssi")
     );
+    assert!(
+        core_interfaces()
+            .iter()
+            .any(|(path, _)| *path == "core/collections/buffer.rssi")
+    );
+    assert!(
+        core_interfaces()
+            .iter()
+            .any(|(path, _)| *path == "core/collections/list.rssi")
+    );
+    assert!(
+        core_interfaces()
+            .iter()
+            .any(|(path, _)| *path == "core/os/os.rssi")
+    );
     assert!(
         core_interfaces()
             .iter()
@@ -326,6 +341,32 @@ pub fn inspect_core(
     assert!(rust.contains("-> Result<Vec<u8>, CoreError>"));
 }
 
+#[test]
+fn rust_lowering_maps_take_consume_core_calls_to_runtime_hooks() {
+    let source = r#"
+features: local
+
+fn close_fd() -> Unit {
+    OS.close(fd: 0)
+}
+
+fn consume_list(list: take List<Int>) -> Unit {
+    List.consume(list: take list)
+}
+
+fn consume_buffer(buffer: take Buffer) -> Unit {
+    Buffer.consume(buffer: take buffer)
+}
+"#;
+    let rust = lower_source_to_rust("consume.rss", source).expect("source should lower");
+
+    assert!(rust.contains("rsscript_runtime::os_close(0);"));
+    assert!(rust.contains("fn consume_list(list: Vec<i64>)"));
+    assert!(rust.contains("rsscript_runtime::list_consume(list);"));
+    assert!(rust.contains("fn consume_buffer(buffer: Vec<u8>)"));
+    assert!(rust.contains("rsscript_runtime::buffer_consume(buffer);"));
+}
+
 #[test]
 fn rust_lowering_maps_file_core_calls_to_runtime_hooks() {
     let source = r#"