Support runnable Result main

Author: olwang

README.md

@@ -382,7 +382,7 @@ source-span hooks for manage and ResourcePool borrow lowering
 central runtime unwrap boundary for generated resource operations
 source map JSON for generated Rust packages
 rustc diagnostic remapping through source maps
-zero-argument `fn main() -> Unit` package harnesses for runnable Rust output
+zero-argument `fn main() -> Unit` and `fn main() -> Result<Unit, E>` package harnesses for runnable Rust output
 core `.rssi` interface signatures
 HIR builtin signatures parsed from `.rssi` interface sources instead of a hand-written Rust table
 CI gates for formatting, linting, tests, and generated Rust fixtures
@@ -414,7 +414,7 @@ rss verify-rust [--json] <file.rss> --out-dir <directory>
 
 The checker prototype also keeps a small `core/prototype` interface bundle for real-scenario fixtures such as CSV, DB, cache, and config examples. Those signatures are still `.rssi` sources, not a second Rust-side builtin table.
 
-If a lowered package contains `fn main() -> Unit`, `rss lower --rust --out-dir` also emits a Rust `src/main.rs` harness. `rss run <file.rss>` uses the same lowering path, writes a temporary Rust package, and delegates execution to `cargo run`. Use `rss run <file.rss> --out-dir <directory>` to keep the generated Rust package for inspection.
+If a lowered package contains `fn main() -> Unit` or `fn main() -> Result<Unit, E>`, `rss lower --rust --out-dir` also emits a Rust `src/main.rs` harness. `rss run <file.rss>` uses the same lowering path, writes a temporary Rust package, and delegates execution to `cargo run`. Use `rss run <file.rss> --out-dir <directory>` to keep the generated Rust package for inspection.
 
 `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.
 
@@ -433,6 +433,12 @@ fn main() -> Unit {
 }
 ```
 
+Result-returning entry points also run:
+
+```sh
+cargo run -- run examples/hello_result.rss
+```
+
 Local verification:
 
 ```sh

examples/hello_result.rss

@@ -0,0 +1,6 @@
+struct MainError
+
+fn main() -> Result<Unit, MainError> {
+    Log.write(message: read "hello RSScript result")
+    return Ok(Unit)
+}

src/main.rs

@@ -335,7 +335,9 @@ fn run_generated_rust(args: &[String]) -> ExitCode {
         }
     };
     if package.main_rs.is_none() {
-        eprintln!("rss run requires a zero-argument `fn main() -> Unit`.");
+        eprintln!(
+            "rss run requires a zero-argument `fn main() -> Unit` or `fn main() -> Result<Unit, E>`."
+        );
         return ExitCode::from(1);
     }
 

src/rust_lower.rs

@@ -1138,31 +1138,59 @@ fn cargo_package_name(name: &str) -> String {
 
 fn rust_package_main(program: &Program, package_name: &str) -> Option<String> {
     let main = program.items.iter().find_map(|item| match item {
-        Item::Function(function) if is_runnable_main(function) => Some(function),
-        Item::Function(_) | Item::Type(_) => None,
+        Item::Function(function) => runnable_main_kind(function).map(|kind| (function, kind)),
+        Item::Type(_) => None,
     })?;
+    let (main, kind) = main;
     let crate_name = cargo_crate_name(package_name);
+    let call = match kind {
+        RunnableMainKind::Unit => format!("{}::{}();", crate_name, rust_ident(&main.name)),
+        RunnableMainKind::ResultUnit => format!(
+            "{}::{}().expect(\"RSScript main returned an error\");",
+            crate_name,
+            rust_ident(&main.name)
+        ),
+    };
     Some(format!(
         concat!(
             "// Generated by RSScript. Edit the .rss source instead.\n",
             "// Runnable harness for RSScript `{}`.\n\n",
             "fn main() {{\n",
-            "    {}::{}();\n",
+            "    {}\n",
             "}}\n"
         ),
-        main.name,
-        crate_name,
-        rust_ident(&main.name)
+        main.name, call
     ))
 }
 
 fn is_runnable_main(function: &FunctionDecl) -> bool {
-    function.name == "main"
-        && function.params.is_empty()
-        && function
-            .return_ty
-            .as_ref()
-            .is_none_or(|return_ty| return_ty.name == "Unit" && return_ty.args.is_empty())
+    runnable_main_kind(function).is_some()
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum RunnableMainKind {
+    Unit,
+    ResultUnit,
+}
+
+fn runnable_main_kind(function: &FunctionDecl) -> Option<RunnableMainKind> {
+    if function.name != "main" || !function.params.is_empty() {
+        return None;
+    }
+    let Some(return_ty) = function.return_ty.as_ref() else {
+        return Some(RunnableMainKind::Unit);
+    };
+    if return_ty.name == "Unit" && return_ty.args.is_empty() {
+        return Some(RunnableMainKind::Unit);
+    }
+    if return_ty.name == "Result"
+        && return_ty.args.len() == 2
+        && return_ty.args[0].name == "Unit"
+        && return_ty.args[0].args.is_empty()
+    {
+        return Some(RunnableMainKind::ResultUnit);
+    }
+    None
 }
 
 fn cargo_crate_name(package_name: &str) -> String {

tests/checker.rs

@@ -586,6 +586,37 @@ fn main() -> Unit {
     assert!(main_rs.contains("runnable_example_rss::main();"));
 }
 
+#[test]
+fn rust_lowering_can_emit_result_main_harness() {
+    let source = r#"
+struct MainError
+
+fn main() -> Result<Unit, MainError> {
+    return Ok(Unit)
+}
+"#;
+    let package = lower_source_to_rust_package(
+        "main.rss",
+        source,
+        "Result Runnable Example.rss",
+        "/workspace/rsscript/runtime",
+    )
+    .expect("source should lower into package");
+    let main_rs = package
+        .main_rs
+        .as_ref()
+        .expect("zero-argument Result<Unit, E> main should emit a Rust binary harness");
+
+    assert!(
+        package
+            .lib_rs
+            .contains("pub fn main() -> Result<(), MainError>")
+    );
+    assert!(main_rs.contains(
+        "result_runnable_example_rss::main().expect(\"RSScript main returned an error\");"
+    ));
+}
+
 #[test]
 fn rust_lowering_is_gated_by_diagnostics() {
     let source = r#"