Add runnable config reload 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`, HTTP handler, and DB resource-pool 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`, `Csv`, `Image`, HTTP handler, DB resource-pool, and config reload 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/config/config.rssi

@@ -0,0 +1,17 @@
+struct ConfigValue
+
+struct ConfigStore
+
+pub fn Config.load(path: read Path) -> Result<fresh ConfigValue, ConfigError>
+
+pub fn Config.name(value: read ConfigValue) -> String
+
+pub fn ConfigStore.new(value: read ConfigValue) -> fresh ConfigStore
+
+pub fn ConfigStore.replace(
+    store: mut ConfigStore,
+    value: read ConfigValue,
+) -> Unit
+    effects(retains(value))
+
+pub fn ConfigStore.name(store: read ConfigStore) -> String

examples/config_reload.rss

@@ -0,0 +1,32 @@
+features: local
+
+fn load_config(path: read String) -> Result<fresh ConfigValue, ConfigError> {
+    return Config.load(path: read path)
+}
+
+fn reload_config(path: read String, store: mut ConfigStore) -> Result<Unit, ConfigError> {
+    let next = load_config(path: read path)?
+    ConfigStore.replace(store: mut store, value: read next)
+    return Ok(Unit)
+}
+
+fn main() -> Result<Unit, ConfigError> {
+    let first = "rsscript-config-first.txt"
+    let second = "rsscript-config-second.txt"
+
+    with File.open_write(path: read first) as file {
+        File.write(file: mut file, data: read "initial\n")?
+    }
+    with File.open_write(path: read second) as file {
+        File.write(file: mut file, data: read "reloaded\n")?
+    }
+
+    let initial = load_config(path: read first)?
+    local store = ConfigStore.new(value: read initial)
+    reload_config(path: read second, store: mut store)?
+
+    let name = ConfigStore.name(store: read store)
+    Assert.equal(left: read name, right: read "reloaded")
+    Log.write(message: read name)
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -29,6 +29,43 @@ pub struct Response {
     body: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConfigValue {
+    name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConfigStore {
+    current: ConfigValue,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConfigError {
+    message: String,
+}
+
+impl ConfigError {
+    fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl fmt::Display for ConfigError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}", self.message)
+    }
+}
+
+impl std::error::Error for ConfigError {}
+
+impl From<std::io::Error> for ConfigError {
+    fn from(error: std::io::Error) -> Self {
+        Self::new(error.to_string())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DbConnection {
     url: String,
@@ -284,6 +321,35 @@ pub fn response_body(response: &Response) -> String {
     response.body.clone()
 }
 
+pub fn config_load<P: RuntimePath + ?Sized>(path: &P) -> Result<ConfigValue, ConfigError> {
+    let text = std::fs::read_to_string(path.as_path())?;
+    let name = text
+        .lines()
+        .map(str::trim)
+        .find(|line| !line.is_empty())
+        .unwrap_or("default")
+        .to_string();
+    Ok(ConfigValue { name })
+}
+
+pub fn config_name(value: &ConfigValue) -> String {
+    value.name.clone()
+}
+
+pub fn config_store_new(value: &ConfigValue) -> ConfigStore {
+    ConfigStore {
+        current: value.clone(),
+    }
+}
+
+pub fn config_store_replace(store: &mut ConfigStore, value: &ConfigValue) {
+    store.current = value.clone();
+}
+
+pub fn config_store_name(store: &ConfigStore) -> String {
+    store.current.name.clone()
+}
+
 pub fn db_connection_open(url: &str) -> DbConnection {
     DbConnection {
         url: url.to_string(),
@@ -883,4 +949,28 @@ mod tests {
 
         assert_eq!(pool.values.borrow().len(), 2);
     }
+
+    #[test]
+    fn config_runtime_hooks_load_and_replace_store() {
+        let first = std::env::temp_dir().join(format!(
+            "rsscript-runtime-config-first-{}.txt",
+            std::process::id()
+        ));
+        let second = std::env::temp_dir().join(format!(
+            "rsscript-runtime-config-second-{}.txt",
+            std::process::id()
+        ));
+        std::fs::write(&first, "initial\n").expect("first config should write");
+        std::fs::write(&second, "reloaded\n").expect("second config should write");
+
+        let initial = super::config_load(&first).expect("initial config should load");
+        let mut store = super::config_store_new(&initial);
+        let reloaded = super::config_load(&second).expect("reloaded config should load");
+        super::config_store_replace(&mut store, &reloaded);
+
+        assert_eq!(super::config_store_name(&store), "reloaded");
+
+        let _ = std::fs::remove_file(first);
+        let _ = std::fs::remove_file(second);
+    }
 }

src/interfaces.rs

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

src/rust_lower.rs

@@ -287,6 +287,7 @@ pub fn check_generated_rust_package(package_dir: &Path) -> Result<RustBackendChe
 struct RustLowerer<'a> {
     program: &'a Program,
     type_kinds: BTreeMap<String, TypeKind>,
+    param_effects: BTreeMap<String, DataEffect>,
     source_map: Vec<RustSourceMapEntry>,
 }
 
@@ -304,6 +305,7 @@ impl<'a> RustLowerer<'a> {
         Self {
             program,
             type_kinds,
+            param_effects: BTreeMap::new(),
             source_map: Vec::new(),
         }
     }
@@ -399,6 +401,12 @@ impl<'a> RustLowerer<'a> {
     }
 
     fn lower_function(&mut self, function: &FunctionDecl, out: &mut String) {
+        let previous_param_effects = std::mem::take(&mut self.param_effects);
+        self.param_effects = function
+            .params
+            .iter()
+            .filter_map(|param| param.effect.map(|effect| (param.name.clone(), effect)))
+            .collect();
         self.record_source_marker(out, 0, "function", &function.span);
         let async_prefix = if function.is_async { "async " } else { "" };
         let is_public = function.is_public || is_runnable_main(function);
@@ -437,6 +445,7 @@ impl<'a> RustLowerer<'a> {
             self.lower_block(&function.body, out, 1);
         }
         out.push_str("}\n");
+        self.param_effects = previous_param_effects;
     }
 
     fn lower_param(&self, param: &Param) -> String {
@@ -740,7 +749,15 @@ impl<'a> RustLowerer<'a> {
             }
             Expr::Effect { effect, value, .. } => match effect {
                 DataEffect::Read => format!("&{}", self.lower_expr(value)),
-                DataEffect::Mut => format!("&mut {}", self.lower_expr(value)),
+                DataEffect::Mut => {
+                    if let Expr::Ident(name, _) = &**value
+                        && self.param_effects.get(name) == Some(&DataEffect::Mut)
+                    {
+                        rust_ident(name)
+                    } else {
+                        format!("&mut {}", self.lower_expr(value))
+                    }
+                }
                 DataEffect::Take => self.lower_expr(value),
             },
             Expr::Manage { value, span } => {
@@ -794,6 +811,9 @@ impl<'a> RustLowerer<'a> {
             "Request" => "rsscript_runtime::Request".to_string(),
             "Response" => "rsscript_runtime::Response".to_string(),
             "HttpError" => "rsscript_runtime::HttpError".to_string(),
+            "ConfigValue" => "rsscript_runtime::ConfigValue".to_string(),
+            "ConfigStore" => "rsscript_runtime::ConfigStore".to_string(),
+            "ConfigError" => "rsscript_runtime::ConfigError".to_string(),
             "DbConnection" => "rsscript_runtime::DbConnection".to_string(),
             "DbError" => "rsscript_runtime::DbError".to_string(),
             "Image" => "rsscript_runtime::Image".to_string(),
@@ -1086,6 +1106,17 @@ fn lower_callee(callee: &Callee) -> String {
             "rsscript_runtime::response_status".to_string()
         }
         callee if is_response_body_callee(callee) => "rsscript_runtime::response_body".to_string(),
+        callee if is_config_load_callee(callee) => "rsscript_runtime::config_load".to_string(),
+        callee if is_config_name_callee(callee) => "rsscript_runtime::config_name".to_string(),
+        callee if is_config_store_new_callee(callee) => {
+            "rsscript_runtime::config_store_new".to_string()
+        }
+        callee if is_config_store_replace_callee(callee) => {
+            "rsscript_runtime::config_store_replace".to_string()
+        }
+        callee if is_config_store_name_callee(callee) => {
+            "rsscript_runtime::config_store_name".to_string()
+        }
         callee if is_db_connection_open_callee(callee) => {
             "rsscript_runtime::db_connection_open".to_string()
         }
@@ -1176,6 +1207,26 @@ fn is_response_body_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Response" && name == "body")
 }
 
+fn is_config_load_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Config" && name == "load")
+}
+
+fn is_config_name_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Config" && name == "name")
+}
+
+fn is_config_store_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ConfigStore" && name == "new")
+}
+
+fn is_config_store_replace_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ConfigStore" && name == "replace")
+}
+
+fn is_config_store_name_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ConfigStore" && name == "name")
+}
+
 fn is_db_connection_open_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "DbConnection" && name == "open")
 }

tests/checker.rs

@@ -457,6 +457,31 @@ fn run_query(url: read Url, sql: read String) -> Result<Unit, DbError> {
     assert!(rust.contains("rsscript_runtime::db_connection_query(&mut conn, &sql)?;"));
 }
 
+#[test]
+fn rust_lowering_maps_config_reload_to_runtime_hooks() {
+    let source = r#"
+features: local
+
+fn load_config(path: read String) -> Result<fresh ConfigValue, ConfigError> {
+    return Config.load(path: read path)
+}
+
+fn reload_config(path: read String, store: mut ConfigStore) -> Result<Unit, ConfigError> {
+    let next = load_config(path: read path)?
+    ConfigStore.replace(store: mut store, value: read next)
+    return Ok(Unit)
+}
+"#;
+    let rust = lower_source_to_rust("config.rss", source).expect("source should lower");
+
+    assert!(
+        rust.contains("-> Result<rsscript_runtime::ConfigValue, rsscript_runtime::ConfigError>")
+    );
+    assert!(rust.contains("return rsscript_runtime::config_load(&path);"));
+    assert!(rust.contains("store: &mut rsscript_runtime::ConfigStore"));
+    assert!(rust.contains("rsscript_runtime::config_store_replace(store, &next);"));
+}
+
 #[test]
 fn rust_lowering_decodes_string_escape_sequences() {
     let source = r#"
@@ -776,7 +801,7 @@ fn pooled(pool: mut ResourcePool<TestConnection>) -> Unit {
     let rust = lower_source_to_rust("pool.rss", source).expect("source should lower");
 
     assert!(rust.contains(
-        "let mut conn = rsscript_runtime::unwrap_runtime(rsscript_runtime::ResourcePool::borrow_at(&mut pool, rsscript_runtime::SourceSpan::new(\"pool.rss\""
+        "let mut conn = rsscript_runtime::unwrap_runtime(rsscript_runtime::ResourcePool::borrow_at(pool, rsscript_runtime::SourceSpan::new(\"pool.rss\""
     ));
 }