rsscript: cache AOT run output, skip re-lowering when source is unchanged

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

Author: olwang

crates/rsscript/src/cli/mod.rs

@@ -186,6 +186,20 @@ pub(crate) fn select_runtime_path(
     ))
 }
 
+/// Resolves the generated package name for `input_path` without performing a
+/// full lowering, so the run cache directory can be located before deciding
+/// whether re-lowering is needed. Returns `None` for a package directory whose
+/// manifest can't be read (the caller then falls back to lowering).
+pub(crate) fn cli_input_package_name(input_path: &str) -> Option<String> {
+    if is_package_directory(input_path) {
+        package_lowering_input(Path::new(input_path))
+            .ok()
+            .map(|input| input.package.name)
+    } else {
+        Some(generated_package_name(input_path))
+    }
+}
+
 pub(crate) fn generated_package_name(path: &str) -> String {
     Path::new(path)
         .file_stem()
@@ -194,6 +208,75 @@ pub(crate) fn generated_package_name(path: &str) -> String {
         .to_string()
 }
 
+/// Computes a content fingerprint of everything that affects the generated Rust
+/// package for `input_path`, so an unchanged run can reuse the cached package and
+/// skip re-lowering. Covers the raw source(s)/interfaces, the runtime path, the
+/// release flag, and a compiler-version marker (so a rebuilt `rss` invalidates
+/// stale generated output). Returns `None` if any input can't be read, which
+/// forces the cautious full lower+write path.
+pub(crate) fn run_input_fingerprint(
+    input_path: &str,
+    runtime_path: &Path,
+    release: bool,
+) -> Option<String> {
+    let mut parts: Vec<String> = Vec::new();
+    // Compiler-version marker: a recompiled `rss` may lower differently.
+    parts.push(format!("rss-version:{}", env!("CARGO_PKG_VERSION")));
+    parts.push(format!("runtime:{}", runtime_path.display()));
+    parts.push(format!("release:{release}"));
+
+    if is_package_directory(input_path) {
+        let input = package_lowering_input(Path::new(input_path)).ok()?;
+        parts.push(format!("package:{}", input.package.name));
+        // Sources/interfaces already carry their contents; include the native
+        // dependency identity (path + features + bindings) since it changes the
+        // generated Cargo.toml and lowering.
+        let mut sources = input.sources.clone();
+        sources.sort();
+        for (path, contents) in &sources {
+            parts.push(format!("src:{path}\n{contents}"));
+        }
+        let mut interfaces = input.interfaces.clone();
+        interfaces.sort();
+        for (path, contents) in &interfaces {
+            parts.push(format!("iface:{path}\n{contents}"));
+        }
+        for dependency in &input.native_dependencies {
+            parts.push(format!(
+                "native:{}|{}|{}|{}",
+                dependency.crate_name,
+                dependency.path,
+                dependency.cargo_features.join(","),
+                dependency
+                    .bindings
+                    .iter()
+                    .map(|(key, value)| format!("{key}={value}"))
+                    .collect::<Vec<_>>()
+                    .join(",")
+            ));
+        }
+    } else {
+        let source = fs::read_to_string(input_path).ok()?;
+        parts.push(format!("file:{input_path}\n{source}"));
+    }
+
+    Some(stable_hash_hex(&parts.join("\u{1e}")))
+}
+
+/// Reads the fingerprint stored alongside a cached generated package.
+pub(crate) fn read_cached_fingerprint(cache_dir: &Path) -> Option<String> {
+    fs::read_to_string(cache_dir.join(".rss-cache-hash"))
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+/// Stores the fingerprint alongside the cached generated package.
+pub(crate) fn write_cached_fingerprint(cache_dir: &Path, fingerprint: &str) {
+    let _ = fs::create_dir_all(cache_dir);
+    let _ = fs::write(cache_dir.join(".rss-cache-hash"), fingerprint);
+}
+
 pub(crate) fn run_cache_dir(input_path: &str, package_name: &str) -> PathBuf {
     let key = stable_input_key(input_path);
     run_cache_root_dir().join(format!(

crates/rsscript/src/cli/run_cmd.rs

@@ -6,9 +6,9 @@ use rsscript::{
 };
 
 use super::{
-    cleanup_temp_dir, default_runtime_path, generated_target_dir_from_env,
-    lower_cli_input_to_rust_package, print_diagnostics, print_usage, required_flag_value,
-    run_cache_dir,
+    cleanup_temp_dir, cli_input_package_name, default_runtime_path, generated_target_dir_from_env,
+    lower_cli_input_to_rust_package, print_diagnostics, print_usage, read_cached_fingerprint,
+    required_flag_value, run_cache_dir, run_input_fingerprint, write_cached_fingerprint,
 };
 
 #[derive(Debug)]
@@ -93,6 +93,35 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
             return ExitCode::from(2);
         }
     };
+    // Fast path: for a default-cache run (no `--out-dir`, not a dry run), reuse a
+    // previously lowered + compiled package when the source, runtime, and release
+    // flag are byte-for-byte unchanged. This skips re-lowering entirely and lets
+    // cargo's own up-to-date check make the rebuild a near no-op (often a direct
+    // run of the cached binary). Correctness: the fingerprint covers every input
+    // that affects generated output, so any change forces the full path below.
+    if !options.dry_run && options.out_dir.is_none() {
+        if let Some(package_name) = cli_input_package_name(path) {
+            let cache_dir = run_cache_dir(path, &package_name);
+            let cached_package_present = cache_dir.join("Cargo.toml").is_file()
+                && cache_dir.join("src/main.rs").is_file();
+            if cached_package_present {
+                if let Some(fingerprint) =
+                    run_input_fingerprint(path, &runtime_path, options.release)
+                {
+                    if read_cached_fingerprint(&cache_dir).as_deref() == Some(fingerprint.as_str()) {
+                        return run_cached_package(
+                            &cache_dir,
+                            options.release,
+                            &options.program_args,
+                            options.json,
+                            stream_stdio,
+                        );
+                    }
+                }
+            }
+        }
+    }
+
     let package = match lower_cli_input_to_rust_package(path, &runtime_path, options.json) {
         Ok(package) => package,
         Err(exit_code) => return exit_code,
@@ -123,6 +152,7 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
         return ExitCode::SUCCESS;
     }
 
+    let is_default_cache = options.out_dir.is_none();
     let package_dir = options
         .out_dir
         .map(PathBuf::from)
@@ -135,8 +165,50 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
         }
         return ExitCode::from(2);
     }
+    // Record the input fingerprint so the next run of unchanged source hits the
+    // fast path above. Only for the default cache dir; a user-chosen `--out-dir`
+    // is left untouched. Written after the package files so a partial write never
+    // leaves a fingerprint claiming a stale package is current.
+    if is_default_cache {
+        if let Some(fingerprint) = run_input_fingerprint(path, &runtime_path, options.release) {
+            write_cached_fingerprint(&package_dir, &fingerprint);
+        }
+    }
+    build_and_run_package(
+        &package_dir,
+        options.release,
+        &options.program_args,
+        options.json,
+        stream_stdio,
+    )
+}
+
+/// Runs the fast-path cache hit: the generated package in `cache_dir` is already
+/// up to date for the current source, so cargo's incremental check makes this a
+/// near no-op build (or a direct run of the cached binary).
+fn run_cached_package(
+    cache_dir: &Path,
+    release: bool,
+    program_args: &[&str],
+    json: bool,
+    stream_stdio: bool,
+) -> ExitCode {
+    build_and_run_package(cache_dir, release, program_args, json, stream_stdio)
+}
+
+/// Invokes `cargo run` for the generated package in `package_dir` and translates
+/// its result into an [`ExitCode`], remapping backend diagnostics for the
+/// captured (non-streaming) path. Shared by the full lower+write path and the
+/// cached fast path so both behave identically.
+fn build_and_run_package(
+    package_dir: &Path,
+    release: bool,
+    program_args: &[&str],
+    json: bool,
+    stream_stdio: bool,
+) -> ExitCode {
     let mut cargo = Command::new("cargo");
-    for arg in cargo_run_args(&package_dir, options.release, &options.program_args) {
+    for arg in cargo_run_args(package_dir, release, program_args) {
         cargo.arg(arg);
     }
     if let Some(target_dir) = generated_target_dir_from_env() {
@@ -154,15 +226,9 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
             Ok(status) => status,
             Err(error) => {
                 eprintln!("failed to run cargo: {error}");
-                if cleanup_package_dir {
-                    cleanup_temp_dir(&package_dir);
-                }
                 return ExitCode::from(2);
             }
         };
-        if cleanup_package_dir {
-            cleanup_temp_dir(&package_dir);
-        }
         return if status.success() {
             ExitCode::SUCCESS
         } else {
@@ -176,9 +242,6 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
         Ok(output) => output,
         Err(error) => {
             eprintln!("failed to run cargo: {error}");
-            if cleanup_package_dir {
-                cleanup_temp_dir(&package_dir);
-            }
             return ExitCode::from(2);
         }
     };
@@ -187,27 +250,18 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
         print!("{stdout}");
     }
     if output.status.success() {
-        if cleanup_package_dir {
-            cleanup_temp_dir(&package_dir);
-        }
         return ExitCode::SUCCESS;
     }
 
     let stderr = String::from_utf8_lossy(&output.stderr);
     let diagnostics = parse_runtime_diagnostics(&stderr);
     if !diagnostics.is_empty() {
-        if cleanup_package_dir {
-            cleanup_temp_dir(&package_dir);
-        }
-        print_diagnostics(options.json, &diagnostics);
+        print_diagnostics(json, &diagnostics);
         return ExitCode::from(1);
     }
-    match check_generated_rust_package(&package_dir) {
+    match check_generated_rust_package(package_dir) {
         Ok(result) if !result.diagnostics.is_empty() => {
-            if cleanup_package_dir {
-                cleanup_temp_dir(&package_dir);
-            }
-            print_diagnostics(options.json, &result.diagnostics);
+            print_diagnostics(json, &result.diagnostics);
             return if result
                 .diagnostics
                 .iter()
@@ -223,9 +277,6 @@ fn run_generated_rust_inner(args: &[String], stream_stdio: bool) -> ExitCode {
             eprintln!("{error}");
         }
     }
-    if cleanup_package_dir {
-        cleanup_temp_dir(&package_dir);
-    }
     if !stderr.trim().is_empty() {
         eprintln!("{}", stderr.trim());
     }