Add Rust backend verification command

Author: olwang

README.md

@@ -380,6 +380,7 @@ rss review [--json] --map <file-or-directory>
 rss lower --rust <file.rss>
 rss lower --rust <file.rss> --out-dir <directory>
 rss remap-rustc [--json] <rsscript-source-map.json> <rustc-json-lines>
+rss verify-rust [--json] <file.rss>
 ```
 
 ---

src/lib.rs

@@ -19,8 +19,9 @@ pub use review::{
     review_sources,
 };
 pub use rust_lower::{
-    GeneratedRustPackage, LoweredRust, RustSourceMapEntry, lower_program_to_rust,
+    GeneratedRustPackage, LoweredRust, RemappedRustcDiagnostic, RustBackendCheckResult,
+    RustSourceMapEntry, check_generated_rust_package, lower_program_to_rust,
     lower_program_to_rust_with_map, lower_source_to_rust, lower_source_to_rust_package,
     lower_source_to_rust_with_map, parse_source_map_json, remap_rustc_diagnostic_json,
-    remap_rustc_diagnostic_json_lines,
+    remap_rustc_diagnostic_json_lines, write_generated_rust_package,
 };

src/main.rs

@@ -2,13 +2,15 @@ use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use rsscript::{
-    analyze_source, explain_diagnostic_code, format_diagnostic_explanation,
-    format_diagnostics_human, format_diagnostics_json, format_review_human, format_review_json,
-    format_review_map_human, format_review_map_json, lower_source_to_rust,
-    lower_source_to_rust_package, parse_source_map_json, remap_rustc_diagnostic_json_lines,
-    review_map_sources, review_sources,
+    Diagnostic, analyze_source, check_generated_rust_package, explain_diagnostic_code,
+    format_diagnostic_explanation, format_diagnostics_human, format_diagnostics_json,
+    format_review_human, format_review_json, format_review_map_human, format_review_map_json,
+    lower_source_to_rust, lower_source_to_rust_package, parse_source_map_json,
+    remap_rustc_diagnostic_json_lines, review_map_sources, review_sources,
+    write_generated_rust_package,
 };
 
 fn main() -> ExitCode {
@@ -24,6 +26,7 @@ fn main() -> ExitCode {
         "review" => run_review(&args[2..]),
         "lower" => run_lower(&args[2..]),
         "remap-rustc" => run_remap_rustc(&args[2..]),
+        "verify-rust" => run_verify_rust(&args[2..]),
         _ => {
             print_usage();
             ExitCode::from(2)
@@ -175,33 +178,8 @@ fn run_lower_rust_package(path: &str, source: &str, out_dir: &str) -> ExitCode {
     };
 
     let out_dir = Path::new(out_dir);
-    let src_dir = out_dir.join("src");
-    if let Err(error) = fs::create_dir_all(&src_dir) {
-        eprintln!("failed to create {}: {error}", src_dir.display());
-        return ExitCode::from(2);
-    }
-    if let Err(error) = fs::write(out_dir.join("Cargo.toml"), package.cargo_toml) {
-        eprintln!(
-            "failed to write {}: {error}",
-            out_dir.join("Cargo.toml").display()
-        );
-        return ExitCode::from(2);
-    }
-    if let Err(error) = fs::write(src_dir.join("lib.rs"), package.lib_rs) {
-        eprintln!(
-            "failed to write {}: {error}",
-            src_dir.join("lib.rs").display()
-        );
-        return ExitCode::from(2);
-    }
-    if let Err(error) = fs::write(
-        out_dir.join("rsscript-source-map.json"),
-        package.source_map_json,
-    ) {
-        eprintln!(
-            "failed to write {}: {error}",
-            out_dir.join("rsscript-source-map.json").display()
-        );
+    if let Err(error) = write_generated_rust_package(out_dir, &package) {
+        eprintln!("{error}");
         return ExitCode::from(2);
     }
 
@@ -213,6 +191,83 @@ fn run_lower_rust_package(path: &str, source: &str, out_dir: &str) -> ExitCode {
     ExitCode::SUCCESS
 }
 
+fn run_verify_rust(args: &[String]) -> ExitCode {
+    let (json, path) = parse_path_args(args);
+    let Some(path) = path else {
+        print_usage();
+        return ExitCode::from(2);
+    };
+    let source = match fs::read_to_string(path) {
+        Ok(source) => source,
+        Err(error) => {
+            eprintln!("failed to read {path}: {error}");
+            return ExitCode::from(2);
+        }
+    };
+    let runtime_path = match default_runtime_path() {
+        Ok(path) => path,
+        Err(error) => {
+            eprintln!("{error}");
+            return ExitCode::from(2);
+        }
+    };
+    let package_name = generated_package_name(path);
+    let package = match lower_source_to_rust_package(
+        path,
+        &source,
+        &package_name,
+        &runtime_path.display().to_string(),
+    ) {
+        Ok(package) => package,
+        Err(diagnostics) => {
+            print_diagnostics(json, &diagnostics);
+            return ExitCode::from(1);
+        }
+    };
+    let temp_dir = verify_temp_dir(&package.package_name);
+    if let Err(error) = write_generated_rust_package(&temp_dir, &package) {
+        eprintln!("{error}");
+        cleanup_temp_dir(&temp_dir);
+        return ExitCode::from(2);
+    }
+    let result = match check_generated_rust_package(&temp_dir) {
+        Ok(result) => result,
+        Err(error) => {
+            eprintln!("{error}");
+            cleanup_temp_dir(&temp_dir);
+            return ExitCode::from(2);
+        }
+    };
+    cleanup_temp_dir(&temp_dir);
+
+    if result.diagnostics.is_empty() {
+        if result.success {
+            if !json {
+                println!("{path}: rust backend ok");
+            } else {
+                println!("[]");
+            }
+            return ExitCode::SUCCESS;
+        }
+        if !result.stderr.trim().is_empty() {
+            eprintln!("{}", result.stderr.trim());
+        }
+        eprintln!("rust backend check failed without mappable diagnostics");
+        return ExitCode::from(1);
+    }
+
+    print_diagnostics(json, &result.diagnostics);
+    if result
+        .diagnostics
+        .iter()
+        .any(|diagnostic| diagnostic.severity.is_error())
+    {
+        ExitCode::from(1)
+    } else {
+        ExitCode::SUCCESS
+    }
+}
+
 fn run_remap_rustc(args: &[String]) -> ExitCode {
     let (json, paths) = parse_multi_path_args(args);
     let [source_map_path, rustc_json_path] = paths.as_slice() else {
@@ -270,6 +325,14 @@ fn run_remap_rustc(args: &[String]) -> ExitCode {
     }
 }
 
+fn print_diagnostics(json: bool, diagnostics: &[Diagnostic]) {
+    if json {
+        println!("{}", format_diagnostics_json(diagnostics));
+    } else {
+        print!("{}", format_diagnostics_human(diagnostics));
+    }
+}
+
 fn parse_explain_args(args: &[String]) -> Option<&str> {
     let [flag, code] = args else {
         return None;
@@ -360,6 +423,21 @@ fn generated_package_name(path: &str) -> String {
         .to_string()
 }
 
+fn verify_temp_dir(package_name: &str) -> PathBuf {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_nanos())
+        .unwrap_or(0);
+    env::temp_dir().join(format!(
+        "rsscript-verify-{package_name}-{}-{now}",
+        std::process::id()
+    ))
+}
+
+fn cleanup_temp_dir(path: &Path) {
+    let _ = fs::remove_dir_all(path);
+}
+
 enum ReviewCommand<'a> {
     Diff {
         json: bool,
@@ -528,6 +606,7 @@ fn print_usage() {
     eprintln!("  rsscript lower --rust <file.rss>");
     eprintln!("  rsscript lower --rust <file.rss> --out-dir <directory>");
     eprintln!("  rsscript remap-rustc [--json] <rsscript-source-map.json> <rustc-json-lines>");
+    eprintln!("  rsscript verify-rust [--json] <file.rss>");
     eprintln!("  rsscript review [--json] --diff <old.rss> <new.rss>");
     eprintln!("  rsscript review [--json] --map <file-or-directory>");
 }

src/rust_lower.rs

@@ -1,4 +1,7 @@
 use std::collections::{BTreeMap, BTreeSet};
+use std::fs;
+use std::path::Path;
+use std::process::Command;
 
 use crate::analyzer::analyze_source;
 use crate::diagnostic::{Diagnostic, Severity, Span, code};
@@ -35,6 +38,14 @@ pub struct RemappedRustcDiagnostic {
     pub mapped: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RustBackendCheckResult {
+    pub success: bool,
+    pub diagnostics: Vec<Diagnostic>,
+    pub cargo_status: Option<i32>,
+    pub stderr: String,
+}
+
 pub fn lower_source_to_rust(file: &str, source: &str) -> Result<String, Vec<Diagnostic>> {
     lower_source_to_rust_with_map(file, source).map(|lowered| lowered.rust_source)
 }
@@ -78,6 +89,38 @@ pub fn lower_source_to_rust_package(
     })
 }
 
+pub fn write_generated_rust_package(
+    out_dir: &Path,
+    package: &GeneratedRustPackage,
+) -> Result<(), String> {
+    let src_dir = out_dir.join("src");
+    fs::create_dir_all(&src_dir)
+        .map_err(|error| format!("failed to create {}: {error}", src_dir.display()))?;
+    fs::write(out_dir.join("Cargo.toml"), &package.cargo_toml).map_err(|error| {
+        format!(
+            "failed to write {}: {error}",
+            out_dir.join("Cargo.toml").display()
+        )
+    })?;
+    fs::write(src_dir.join("lib.rs"), &package.lib_rs).map_err(|error| {
+        format!(
+            "failed to write {}: {error}",
+            src_dir.join("lib.rs").display()
+        )
+    })?;
+    fs::write(
+        out_dir.join("rsscript-source-map.json"),
+        &package.source_map_json,
+    )
+    .map_err(|error| {
+        format!(
+            "failed to write {}: {error}",
+            out_dir.join("rsscript-source-map.json").display()
+        )
+    })?;
+    Ok(())
+}
+
 pub fn lower_program_to_rust(program: &Program) -> String {
     lower_program_to_rust_with_map(program).rust_source
 }
@@ -95,7 +138,12 @@ pub fn remap_rustc_diagnostic_json(
     source_map: &[RustSourceMapEntry],
     rustc_json: &str,
 ) -> Result<Option<RemappedRustcDiagnostic>, String> {
-    let rustc: RustcJsonDiagnostic = serde_json::from_str(rustc_json)
+    let value: serde_json::Value = serde_json::from_str(rustc_json)
+        .map_err(|error| format!("failed to parse rustc JSON line: {error}"))?;
+    let Some(value) = rustc_diagnostic_value(&value) else {
+        return Ok(None);
+    };
+    let rustc: RustcJsonDiagnostic = serde_json::from_value(value.clone())
         .map_err(|error| format!("failed to parse rustc JSON diagnostic: {error}"))?;
     if !matches!(rustc.level.as_str(), "error" | "warning") {
         return Ok(None);
@@ -183,6 +231,38 @@ pub fn remap_rustc_diagnostic_json_lines(
     Ok(diagnostics)
 }
 
+pub fn check_generated_rust_package(package_dir: &Path) -> Result<RustBackendCheckResult, String> {
+    let source_map_json = fs::read_to_string(package_dir.join("rsscript-source-map.json"))
+        .map_err(|error| {
+            format!(
+                "failed to read {}: {error}",
+                package_dir.join("rsscript-source-map.json").display()
+            )
+        })?;
+    let source_map = parse_source_map_json(&source_map_json)?;
+    let manifest_path = package_dir.join("Cargo.toml");
+    let output = Command::new("cargo")
+        .arg("check")
+        .arg("--manifest-path")
+        .arg(&manifest_path)
+        .arg("--message-format=json")
+        .output()
+        .map_err(|error| format!("failed to run cargo check: {error}"))?;
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let remapped = remap_rustc_diagnostic_json_lines(&source_map, &stdout)?;
+    let diagnostics = remapped
+        .into_iter()
+        .map(|remapped| remapped.diagnostic)
+        .collect();
+
+    Ok(RustBackendCheckResult {
+        success: output.status.success(),
+        diagnostics,
+        cargo_status: output.status.code(),
+        stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+    })
+}
+
 struct RustLowerer<'a> {
     program: &'a Program,
     type_kinds: BTreeMap<String, TypeKind>,
@@ -717,6 +797,16 @@ fn rustc_severity(level: &str) -> Severity {
     }
 }
 
+fn rustc_diagnostic_value(value: &serde_json::Value) -> Option<&serde_json::Value> {
+    if value.get("level").is_some() && value.get("message").is_some() {
+        return Some(value);
+    }
+    if value.get("reason").and_then(serde_json::Value::as_str) == Some("compiler-message") {
+        return value.get("message");
+    }
+    None
+}
+
 fn generated_span_from_rustc(span: &RustcJsonSpan) -> Span {
     Span {
         file: span.file_name.clone(),

tests/checker.rs

@@ -198,8 +198,8 @@ fn rustc_diagnostics_report_unmappable_generated_spans() {
 
 #[test]
 fn rustc_diagnostic_line_remap_ignores_non_diagnostic_messages() {
-    let lines = r#"{"message":"build finished","level":"note","spans":[]}
-{"message":"cannot find value","code":{"code":"E0425","explanation":null},"level":"error","spans":[{"file_name":"src/lib.rs","line_start":99,"line_end":99,"column_start":5,"column_end":10,"is_primary":true}]}"#;
+    let lines = r#"{"reason":"compiler-artifact","target":{"name":"generated"}}
+{"reason":"compiler-message","message":{"message":"cannot find value","code":{"code":"E0425","explanation":null},"level":"error","spans":[{"file_name":"src/lib.rs","line_start":99,"line_end":99,"column_start":5,"column_end":10,"is_primary":true}]}}"#;
 
     let remapped =
         remap_rustc_diagnostic_json_lines(&[], lines).expect("rustc JSON lines should parse");