Add runnable Json runtime hooks

Author: olwang

Cargo.lock

@@ -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` 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` 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.
 
 Smallest runnable example:
 

README.md

@@ -2,8 +2,12 @@ struct JsonValue
 
 pub fn Json.parse(text: read String) -> Result<fresh JsonValue, JsonError>
 
+pub fn Json.field(
+    value: read JsonValue,
+    name: read String,
+) -> Result<fresh JsonValue, JsonError>
+
 pub fn Json.field_string(
     value: read JsonValue,
     name: read String,
 ) -> Result<String, JsonError>
-

core/json/json.rssi

@@ -0,0 +1,9 @@
+fn main() -> Result<Unit, JsonError> {
+    let value = Json.parse(text: read "{\"profile\":{\"name\":\"RSScript\"}}")?
+    let profile = Json.field(value: read value, name: read "profile")?
+    let name = Json.field_string(value: read profile, name: read "name")?
+
+    Assert.equal(left: read name, right: read "RSScript")
+    Log.write(message: read name)
+    return Ok(Unit)
+}

examples/json_nested.rss

@@ -10,3 +10,4 @@ name = "rsscript_runtime"
 path = "src/lib.rs"
 
 [dependencies]
+serde_json = "1"

runtime/Cargo.toml

@@ -17,6 +17,38 @@ pub struct File {
 
 impl Resource for File {}
 
+#[derive(Debug, Clone)]
+pub struct JsonValue {
+    inner: serde_json::Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct JsonError {
+    message: String,
+}
+
+impl JsonError {
+    fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl fmt::Display for JsonError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}", self.message)
+    }
+}
+
+impl std::error::Error for JsonError {}
+
+impl From<serde_json::Error> for JsonError {
+    fn from(error: serde_json::Error) -> Self {
+        Self::new(error.to_string())
+    }
+}
+
 pub trait RuntimePath {
     fn as_path(&self) -> &std::path::Path;
 }
@@ -95,6 +127,31 @@ pub fn file_write<B: RuntimeBytes + ?Sized>(file: &mut File, data: &B) -> std::i
     file.inner.write_all(data.as_bytes_slice())
 }
 
+pub fn json_parse(text: &str) -> Result<JsonValue, JsonError> {
+    serde_json::from_str(text)
+        .map(|inner| JsonValue { inner })
+        .map_err(JsonError::from)
+}
+
+pub fn json_field(value: &JsonValue, name: &str) -> Result<JsonValue, JsonError> {
+    let Some(field) = value.inner.get(name) else {
+        return Err(JsonError::new(format!("missing JSON field `{name}`")));
+    };
+    Ok(JsonValue {
+        inner: field.clone(),
+    })
+}
+
+pub fn json_field_string(value: &JsonValue, name: &str) -> Result<String, JsonError> {
+    let field = json_field(value, name)?;
+    let Some(text) = field.inner.as_str() else {
+        return Err(JsonError::new(format!(
+            "JSON field `{name}` is not a string"
+        )));
+    };
+    Ok(text.to_string())
+}
+
 #[derive(Clone)]
 pub struct Gc<T> {
     inner: Rc<RefCell<T>>,
@@ -468,4 +525,15 @@ mod tests {
         assert_eq!(bytes, b"hello file");
         let _ = std::fs::remove_file(path);
     }
+
+    #[test]
+    fn json_runtime_hooks_parse_nested_fields() {
+        let value =
+            super::json_parse(r#"{"profile":{"name":"RSScript"}}"#).expect("JSON should parse");
+        let profile = super::json_field(&value, "profile").expect("profile field should exist");
+        let name =
+            super::json_field_string(&profile, "name").expect("name field should be a string");
+
+        assert_eq!(name, "RSScript");
+    }
 }

runtime/src/lib.rs

@@ -663,7 +663,7 @@ impl<'a> RustLowerer<'a> {
                 .map(str::to_string)
                 .unwrap_or_else(|| rust_ident(name)),
             Expr::Number(value, _) => value.clone(),
-            Expr::String(value, _) => format!("{value:?}.to_string()"),
+            Expr::String(value, _) => format!("{:?}.to_string()", decode_string_token(value)),
             Expr::Binary {
                 op, left, right, ..
             } => {
@@ -783,6 +783,8 @@ impl<'a> RustLowerer<'a> {
             "Path" => "std::path::PathBuf".to_string(),
             "File" => "rsscript_runtime::File".to_string(),
             "FileError" | "IOError" => "std::io::Error".to_string(),
+            "JsonValue" => "rsscript_runtime::JsonValue".to_string(),
+            "JsonError" => "rsscript_runtime::JsonError".to_string(),
             "Result" if ty.args.len() == 2 => format!(
                 "Result<{}, {}>",
                 self.lower_type_ref(&ty.args[0], ManagedPosition::Nested),
@@ -1059,6 +1061,11 @@ fn lower_callee(callee: &Callee) -> 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 if is_json_parse_callee(callee) => "rsscript_runtime::json_parse".to_string(),
+        callee if is_json_field_callee(callee) => "rsscript_runtime::json_field".to_string(),
+        callee if is_json_field_string_callee(callee) => {
+            "rsscript_runtime::json_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))
@@ -1101,6 +1108,18 @@ fn is_file_write_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "File" && name == "write")
 }
 
+fn is_json_parse_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Json" && name == "parse")
+}
+
+fn is_json_field_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Json" && name == "field")
+}
+
+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_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))
 }
@@ -1143,6 +1162,31 @@ fn lower_builtin_value_ident(name: &str) -> Option<&'static str> {
     }
 }
 
+fn decode_string_token(value: &str) -> String {
+    let mut decoded = String::new();
+    let mut chars = value.chars();
+    while let Some(ch) = chars.next() {
+        if ch != '\\' {
+            decoded.push(ch);
+            continue;
+        }
+        match chars.next() {
+            Some('n') => decoded.push('\n'),
+            Some('r') => decoded.push('\r'),
+            Some('t') => decoded.push('\t'),
+            Some('\\') => decoded.push('\\'),
+            Some('"') => decoded.push('"'),
+            Some('0') => decoded.push('\0'),
+            Some(other) => {
+                decoded.push('\\');
+                decoded.push(other);
+            }
+            None => decoded.push('\\'),
+        }
+    }
+    decoded
+}
+
 fn is_rust_enum_constructor(name: &str) -> bool {
     matches!(name, "Ok" | "Err" | "Some")
 }

src/rust_lower.rs

@@ -333,6 +333,43 @@ fn copy_file(input: read Path, output: read Path) -> Result<Unit, IOError> {
     assert!(rust.contains("rsscript_runtime::file_write(&mut writer, &bytes)?;"));
 }
 
+#[test]
+fn rust_lowering_maps_json_core_calls_to_runtime_hooks() {
+    let source = r#"
+fn read_name(text: read String) -> Result<String, JsonError> {
+    let value = Json.parse(text: read text)?
+    let profile = Json.field(value: read value, name: read "profile")?
+    return Json.field_string(value: read profile, name: read "name")
+}
+"#;
+    let rust = lower_source_to_rust("json.rss", source).expect("source should lower");
+
+    assert!(rust.contains("-> Result<String, rsscript_runtime::JsonError>"));
+    assert!(rust.contains("let value = rsscript_runtime::json_parse(&text)?;"));
+    assert!(rust.contains(
+        "let profile = rsscript_runtime::json_field(&value, &\"profile\".to_string())?;"
+    ));
+    assert!(
+        rust.contains(
+            "return rsscript_runtime::json_field_string(&profile, &\"name\".to_string());"
+        )
+    );
+}
+
+#[test]
+fn rust_lowering_decodes_string_escape_sequences() {
+    let source = r#"
+fn json_text() -> String {
+    return "{\"profile\":{\"name\":\"RSScript\"}}"
+}
+"#;
+    let rust = lower_source_to_rust("string-escapes.rss", source).expect("source should lower");
+
+    assert!(
+        rust.contains("return \"{\\\"profile\\\":{\\\"name\\\":\\\"RSScript\\\"}}\".to_string();")
+    );
+}
+
 #[test]
 fn rust_lowering_maps_log_write_to_runtime_output_hook() {
     let source = r#"
@@ -1241,6 +1278,11 @@ struct JsonValue
 
 pub fn parse(text: read String) -> Result<fresh JsonValue, JsonError>
 
+pub fn field(
+    value: read JsonValue,
+    name: read String,
+) -> Result<fresh JsonValue, JsonError>
+
 pub fn field_string(
     value: read JsonValue,
     name: read String,
@@ -1249,13 +1291,16 @@ pub fn field_string(
     let program = parse_source("json.rssi", source);
 
     assert!(program.features.is_empty());
-    assert_eq!(program.items.len(), 3);
+    assert_eq!(program.items.len(), 4);
     assert!(matches!(&program.items[0], Item::Type(type_decl) if type_decl.name == "JsonValue"));
     assert!(
         matches!(&program.items[1], Item::Function(function) if function.name == "parse" && function.is_public && function.body.statements.is_empty())
     );
     assert!(
-        matches!(&program.items[2], Item::Function(function) if function.name == "field_string" && function.is_public && function.body.statements.is_empty())
+        matches!(&program.items[2], Item::Function(function) if function.name == "field" && function.is_public && function.body.statements.is_empty())
+    );
+    assert!(
+        matches!(&program.items[3], Item::Function(function) if function.name == "field_string" && function.is_public && function.body.statements.is_empty())
     );
     assert!(analyze_source("json.rssi", source).is_empty());
 }