fix(lowering): sanitize Rust-keyword crate names (async.rss -> rss-async)

A source file named after a Rust keyword (e.g. `async.rss`, `match.rss`) derived
a keyword crate/lib name, so the generated harness emitted `async::main()` — a
Rust parse error surfaced as RS1102, and both Cargo and rustc reject keyword
crate names. The checker accepted such programs; only the backend failed,
violating the "valid RSScript -> valid Rust" contract.

`cargo_package_name` now prefixes a keyword result with `rss-` (`async` ->
`rss-async`), which flows through to the lib name and the `<crate>::main()`
reference (`rss_async::main()`), all valid. Extracted the keyword set shared with
`rust_ident` into `is_rust_keyword`. Regression test in checker_lowering.

Third "valid RSScript -> invalid Rust" bug found while building rss-testgen (the
async tier surfaced it via a keyword-named scratch file).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Haofei

crates/rsscript/src/rust_lower/helpers.rs

@@ -1558,18 +1558,21 @@ pub(super) fn rust_path_segment(segment: &str) -> String {
     }
 }
 
-pub(super) fn rust_ident(name: &str) -> String {
-    let keywords: BTreeSet<&'static str> = [
+/// Whether `name` is a Rust keyword (strict or reserved) that cannot be used as a
+/// bare identifier.
+pub(super) fn is_rust_keyword(name: &str) -> bool {
+    const KEYWORDS: &[&str] = &[
         "abstract", "as", "async", "await", "become", "box", "break", "const", "continue", "crate",
         "do", "dyn", "else", "enum", "extern", "false", "final", "fn", "for", "gen", "if", "impl",
         "in", "let", "loop", "macro", "match", "mod", "move", "mut", "override", "priv", "pub",
         "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "try",
         "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while", "yield",
-    ]
-    .into_iter()
-    .collect();
+    ];
+    KEYWORDS.contains(&name)
+}
 
-    if keywords.contains(name) {
+pub(super) fn rust_ident(name: &str) -> String {
+    if is_rust_keyword(name) {
         format!("r#{name}")
     } else {
         name.to_string()
@@ -1620,6 +1623,12 @@ pub(super) fn cargo_package_name(name: &str) -> String {
 
     if out.is_empty() {
         "rsscript-generated".to_string()
+    } else if is_rust_keyword(&out) {
+        // A package named after a Rust keyword (e.g. `async.rss`) would derive a
+        // keyword crate/lib name, which both Cargo and rustc reject (and the
+        // generated `async::main()` harness is a parse error). Prefix it so the
+        // package name, lib name, and `<crate>::main()` reference are all valid.
+        format!("rss-{out}")
     } else {
         out
     }

crates/rsscript/tests/checker_lowering/misc.rs

@@ -2,6 +2,33 @@
 #![allow(unused_imports, dead_code)]
 use super::*;
 
+#[test]
+fn keyword_named_source_lowers_to_a_valid_crate_name() {
+    // Regression (found while building rss-testgen's async tier): a source whose
+    // name is a Rust keyword (e.g. `async.rss`) derived a keyword crate name, so
+    // the harness emitted `async::main()` — a Rust parse error (RS1102), and both
+    // Cargo and rustc reject keyword crate names. The package/lib/crate-reference
+    // names must all be sanitized.
+    let source = "fn main() -> Unit {\n    Log.write(message: read \"ok\")\n    return Unit\n}\n";
+    let package = lower_source_to_rust_package("async.rss", source, "async", "/tmp/runtime")
+        .expect("keyword-named source should lower");
+
+    assert_ne!(
+        package.package_name, "async",
+        "package name must not be the bare keyword"
+    );
+    let main_rs = package.main_rs.expect("runnable main");
+    assert!(
+        main_rs.contains("rss_async::main"),
+        "main.rs should reference the sanitized crate name, not the keyword:\n{main_rs}"
+    );
+    // No bare keyword crate path (e.g. a line starting `    async::`).
+    assert!(
+        !main_rs.contains(" async::") && !main_rs.contains("\nasync::"),
+        "main.rs must not reference a bare keyword crate:\n{main_rs}"
+    );
+}
+
 #[test]
 fn rust_lowering_emits_checked_rust_source() {
     let source = r#"