Lower core surface types to Rust std types

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, and `Option<T>` constructors lower to the corresponding Rust literals, operators, and enum constructors; user-defined operator overloading remains forbidden.
+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.
 
 Smallest runnable example:
 

src/rust_lower.rs

@@ -761,11 +761,24 @@ impl<'a> RustLowerer<'a> {
         let lowered = match ty.name.as_str() {
             "Unit" => "()".to_string(),
             "Bool" => "bool".to_string(),
+            "Byte" => "u8".to_string(),
+            "Char" => "char".to_string(),
             "Int" => "i64".to_string(),
+            "Int8" => "i8".to_string(),
+            "Int16" => "i16".to_string(),
+            "Int32" => "i32".to_string(),
             "Int64" => "i64".to_string(),
+            "UInt" => "u64".to_string(),
+            "UInt8" => "u8".to_string(),
+            "UInt16" => "u16".to_string(),
+            "UInt32" => "u32".to_string(),
             "UInt64" => "u64".to_string(),
             "Float" => "f64".to_string(),
+            "Float32" => "f32".to_string(),
+            "Float64" => "f64".to_string(),
             "String" => "String".to_string(),
+            "Bytes" | "Buffer" => "Vec<u8>".to_string(),
+            "Path" => "std::path::PathBuf".to_string(),
             "Result" if ty.args.len() == 2 => format!(
                 "Result<{}, {}>",
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested),
@@ -788,6 +801,12 @@ impl<'a> RustLowerer<'a> {
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested),
                 self.lower_type_ref(&ty.args[1], ManagedPosition::Nested)
             ),
+            "Set" if ty.args.len() == 1 => {
+                format!(
+                    "std::collections::HashSet<{}>",
+                    self.lower_type_ref(&ty.args[0], ManagedPosition::Nested)
+                )
+            }
             "ResourcePool" if ty.args.len() == 1 => format!(
                 "rsscript_runtime::ResourcePool<{}>",
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested)

tests/checker.rs

@@ -282,6 +282,35 @@ pub fn maybe_value(flag: Bool) -> Option<Int> {
     assert!(rust.contains("return None;"));
 }
 
+#[test]
+fn rust_lowering_maps_core_surface_types_to_rust_std_types() {
+    let source = r#"
+struct CoreError {
+    code: Int
+}
+
+pub fn inspect_core(
+    path: read Path,
+    bytes: read Bytes,
+    buffer: mut Buffer,
+    names: read Set<String>,
+    counts: read Map<String, Int>,
+    items: read List<Int>,
+) -> Result<fresh Bytes, CoreError> {
+    return Err(CoreError(code: 0))
+}
+"#;
+    let rust = lower_source_to_rust("core-types.rss", source).expect("source should lower");
+
+    assert!(rust.contains("path: &std::path::PathBuf"));
+    assert!(rust.contains("bytes: &Vec<u8>"));
+    assert!(rust.contains("buffer: &mut Vec<u8>"));
+    assert!(rust.contains("names: &std::collections::HashSet<String>"));
+    assert!(rust.contains("counts: &std::collections::HashMap<String, i64>"));
+    assert!(rust.contains("items: &Vec<i64>"));
+    assert!(rust.contains("-> Result<Vec<u8>, CoreError>"));
+}
+
 #[test]
 fn rust_lowering_maps_log_write_to_runtime_output_hook() {
     let source = r#"