Surface runtime conflicts as RSScript diagnostics

Author: olwang

runtime/src/lib.rs

@@ -7,6 +7,8 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::str::Utf8Error;
 
+pub const RUNTIME_DIAGNOSTIC_PREFIX: &str = "RSSCRIPT_RUNTIME_DIAGNOSTIC:";
+
 pub trait Managed {}
 
 impl<T: 'static> Managed for T {}
@@ -765,13 +767,17 @@ impl<T> Gc<T> {
     }
 
     pub fn read(&self) -> GcRead<'_, T> {
-        self.try_read()
-            .expect("RSScript runtime read conflict should be reported through diagnostics")
+        match self.try_read() {
+            Ok(value) => value,
+            Err(error) => panic_runtime_error(error),
+        }
     }
 
     pub fn write(&self) -> GcWrite<'_, T> {
-        self.try_write()
-            .expect("RSScript runtime write conflict should be reported through diagnostics")
+        match self.try_write() {
+            Ok(value) => value,
+            Err(error) => panic_runtime_error(error),
+        }
     }
 
     pub fn ptr_eq(left: &Self, right: &Self) -> bool {
@@ -798,7 +804,10 @@ pub fn manage_at<T>(value: T, span: SourceSpan) -> Gc<T> {
 }
 
 pub fn unwrap_runtime<T>(result: Result<T, RuntimeError>) -> T {
-    result.expect("RSScript runtime error should be reported through diagnostics")
+    match result {
+        Ok(value) => value,
+        Err(error) => panic_runtime_error(error),
+    }
 }
 
 pub fn log_write(message: &str) {
@@ -867,6 +876,25 @@ impl RuntimeError {
         self.span = Some(span);
         self
     }
+
+    pub fn diagnostic_json(&self) -> String {
+        let span = self
+            .span
+            .clone()
+            .unwrap_or_else(|| SourceSpan::new("<runtime>", 1, 1, 1));
+        serde_json::json!({
+            "code": "RS1201",
+            "severity": "error",
+            "summary": format!("RSScript runtime error: {}", self.message),
+            "file": span.file,
+            "line": span.line,
+            "column": span.column,
+            "length": span.length,
+            "label": self.message,
+            "kind": self.kind.as_str(),
+        })
+        .to_string()
+    }
 }
 
 impl fmt::Display for RuntimeError {
@@ -897,6 +925,21 @@ impl From<BorrowMutError> for RuntimeError {
     }
 }
 
+impl RuntimeErrorKind {
+    fn as_str(&self) -> &'static str {
+        match self {
+            Self::ManagedReadConflict => "managed_read_conflict",
+            Self::ManagedWriteConflict => "managed_write_conflict",
+            Self::ResourcePoolBorrowConflict => "resource_pool_borrow_conflict",
+            Self::ResourcePoolEmpty => "resource_pool_empty",
+        }
+    }
+}
+
+fn panic_runtime_error(error: RuntimeError) -> ! {
+    panic!("{}{}", RUNTIME_DIAGNOSTIC_PREFIX, error.diagnostic_json())
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SourceSpan {
     pub file: &'static str,

src/diagnostic.rs

@@ -48,6 +48,7 @@ pub mod code {
     pub const SURFACE_REFERENCE_ATTEMPT: &str = "RS1004";
     pub const RUSTC_DIAGNOSTIC_MAPPED: &str = "RS1101";
     pub const RUSTC_DIAGNOSTIC_UNMAPPABLE: &str = "RS1102";
+    pub const RUNTIME_DIAGNOSTIC: &str = "RS1201";
     pub const LINT_SIGNATURE_COMPLEXITY: &str = "RSL001";
     pub const LINT_DUPLICATE_EFFECT: &str = "RSL002";
 
@@ -454,6 +455,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "unmappable rustc diagnostic",
         explanation: "rustc reported a backend diagnostic whose generated Rust location could not be mapped back to RSScript source. The compiler should surface the generated Rust reference as secondary internal detail instead of exposing raw rustc output as the primary diagnostic.",
     },
+    DiagnosticExplanation {
+        code: code::RUNTIME_DIAGNOSTIC,
+        title: "runtime diagnostic",
+        explanation: "The RSScript runtime reported a managed aliasing or resource conflict with an RSScript source span. Runtime diagnostics should be surfaced as RSScript diagnostics instead of raw Rust panics.",
+    },
     DiagnosticExplanation {
         code: code::LINT_SIGNATURE_COMPLEXITY,
         title: "signature complexity lint",

src/lib.rs

@@ -27,6 +27,6 @@ pub use rust_lower::{
     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, write_generated_rust_package,
+    lower_source_to_rust_with_map, parse_runtime_diagnostics, parse_source_map_json,
+    remap_rustc_diagnostic_json, remap_rustc_diagnostic_json_lines, write_generated_rust_package,
 };

src/main.rs

@@ -9,8 +9,9 @@ use rsscript::{
     core_interfaces, 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, lint_source, 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,
+    lower_source_to_rust_package, parse_runtime_diagnostics, parse_source_map_json,
+    remap_rustc_diagnostic_json_lines, review_map_sources, review_sources,
+    write_generated_rust_package,
 };
 
 fn main() -> ExitCode {
@@ -409,14 +410,14 @@ fn run_generated_rust(args: &[String]) -> ExitCode {
         }
         return ExitCode::from(2);
     }
-    let status = match Command::new("cargo")
+    let output = match Command::new("cargo")
         .arg("run")
         .arg("--quiet")
         .arg("--manifest-path")
         .arg(package_dir.join("Cargo.toml"))
-        .status()
+        .output()
     {
-        Ok(status) => status,
+        Ok(output) => output,
         Err(error) => {
             eprintln!("failed to run cargo: {error}");
             if cleanup_package_dir {
@@ -429,7 +430,25 @@ fn run_generated_rust(args: &[String]) -> ExitCode {
         cleanup_temp_dir(&package_dir);
     }
 
-    status
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    if !stdout.is_empty() {
+        print!("{stdout}");
+    }
+    if output.status.success() {
+        return ExitCode::SUCCESS;
+    }
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let diagnostics = parse_runtime_diagnostics(&stderr);
+    if !diagnostics.is_empty() {
+        print_diagnostics(false, &diagnostics);
+        return ExitCode::from(1);
+    }
+    if !stderr.trim().is_empty() {
+        eprintln!("{}", stderr.trim());
+    }
+    output
+        .status
         .code()
         .map(|code| ExitCode::from(code as u8))
         .unwrap_or_else(|| ExitCode::from(1))

src/rust_lower.rs

@@ -49,6 +49,21 @@ pub struct RustBackendCheckResult {
     pub stderr: String,
 }
 
+const RUNTIME_DIAGNOSTIC_PREFIX: &str = "RSSCRIPT_RUNTIME_DIAGNOSTIC:";
+
+#[derive(serde::Deserialize)]
+struct RuntimeDiagnosticJson {
+    code: Option<String>,
+    severity: Option<String>,
+    summary: String,
+    file: String,
+    line: usize,
+    column: usize,
+    length: usize,
+    label: String,
+    kind: Option<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)
 }
@@ -143,6 +158,36 @@ pub fn write_generated_rust_package(
     Ok(())
 }
 
+pub fn parse_runtime_diagnostics(stderr: &str) -> Vec<Diagnostic> {
+    stderr
+        .lines()
+        .filter_map(parse_runtime_diagnostic_line)
+        .collect()
+}
+
+fn parse_runtime_diagnostic_line(line: &str) -> Option<Diagnostic> {
+    let start = line.find(RUNTIME_DIAGNOSTIC_PREFIX)? + RUNTIME_DIAGNOSTIC_PREFIX.len();
+    let payload = &line[start..];
+    let wire: RuntimeDiagnosticJson = serde_json::from_str(payload).ok()?;
+    let code = wire
+        .code
+        .unwrap_or_else(|| code::RUNTIME_DIAGNOSTIC.to_string());
+    let span = Span {
+        file: wire.file,
+        line: wire.line,
+        column: wire.column,
+        length: wire.length,
+    };
+    let mut diagnostic = match wire.severity.as_deref() {
+        Some("warning") => Diagnostic::warning(&code, wire.summary, span, wire.label),
+        _ => Diagnostic::error(&code, wire.summary, span, wire.label),
+    };
+    if let Some(kind) = wire.kind {
+        diagnostic = diagnostic.with_cause(format!("runtime error kind: {kind}"));
+    }
+    Some(diagnostic)
+}
+
 pub fn lower_program_to_rust(program: &Program) -> String {
     lower_program_to_rust_with_map(program).rust_source
 }

tests/checker.rs

@@ -1,5 +1,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use rsscript::syntax::ast::Item;
 use rsscript::syntax::parse_source;
@@ -9,8 +11,8 @@ use rsscript::{
     explain_diagnostic_code, format_diagnostic_explanation, format_diagnostics_json,
     format_review_human, format_review_json, format_review_map_human, format_review_map_json,
     lint_source, lower_source_to_rust, lower_source_to_rust_package, lower_source_to_rust_with_map,
-    remap_rustc_diagnostic_json, remap_rustc_diagnostic_json_lines, review_map_sources,
-    review_sources,
+    parse_runtime_diagnostics, remap_rustc_diagnostic_json, remap_rustc_diagnostic_json_lines,
+    review_map_sources, review_sources,
 };
 use serde_json::Value;
 
@@ -1077,6 +1079,79 @@ fn rustc_diagnostic_line_remap_ignores_non_diagnostic_messages() {
     assert_eq!(remapped[0].diagnostic.code, "RS1102");
 }
 
+#[test]
+fn runtime_diagnostic_lines_parse_to_rsscript_diagnostics() {
+    let stderr = r#"thread 'main' panicked at runtime/src/lib.rs:1:1:
+RSSCRIPT_RUNTIME_DIAGNOSTIC:{"code":"RS1201","severity":"error","summary":"RSScript runtime error: resource pool has no available resources","file":"pool.rss","line":8,"column":10,"length":24,"label":"resource pool has no available resources","kind":"resource_pool_empty"}
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace"#;
+
+    let diagnostics = parse_runtime_diagnostics(stderr);
+
+    assert_eq!(diagnostics.len(), 1);
+    assert_eq!(diagnostics[0].code, "RS1201");
+    assert_eq!(
+        diagnostics[0].summary,
+        "RSScript runtime error: resource pool has no available resources"
+    );
+    assert_eq!(diagnostics[0].span.file, "pool.rss");
+    assert_eq!(diagnostics[0].span.line, 8);
+    assert!(
+        diagnostics[0]
+            .causes
+            .iter()
+            .any(|cause| cause == "runtime error kind: resource_pool_empty")
+    );
+}
+
+#[test]
+fn rss_run_maps_runtime_conflict_to_rsscript_diagnostic() {
+    let temp_dir = unique_temp_dir("rsscript-runtime-diagnostic");
+    fs::create_dir_all(&temp_dir).expect("temp dir should be created");
+    let source_path = temp_dir.join("empty_pool.rss");
+    fs::write(
+        &source_path,
+        r#"features: local
+
+fn main() -> Unit {
+    local pool = ResourcePool<DbConnection>.new(
+        create: || DbConnection.open(url: read "db://local"),
+        max_size: 0,
+    )
+
+    with ResourcePool.borrow(pool: mut pool) as conn {
+        Log.write(message: read "unreachable")
+    }
+
+    return Unit
+}
+"#,
+    )
+    .expect("runtime diagnostic fixture should be written");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_rss"))
+        .arg("run")
+        .arg(&source_path)
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .expect("rss run should execute");
+    let _ = fs::remove_dir_all(&temp_dir);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(!output.status.success());
+    assert!(stderr.trim().is_empty(), "{stderr}");
+    assert!(stdout.contains("error[RS1201]"), "{stdout}");
+    assert!(
+        stdout.contains("RSScript runtime error: resource pool has no available resources"),
+        "{stdout}"
+    );
+    assert!(stdout.contains("empty_pool.rss"), "{stdout}");
+    assert!(
+        stdout.contains("runtime error kind: resource_pool_empty"),
+        "{stdout}"
+    );
+}
+
 #[test]
 fn rust_lowering_targets_runtime_crate_hooks() {
     let source = r#"
@@ -2152,6 +2227,14 @@ fn read_fixture(path: &Path) -> String {
         .unwrap_or_else(|error| panic!("failed to read {}: {error}", path.display()))
 }
 
+fn unique_temp_dir(prefix: &str) -> PathBuf {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_nanos())
+        .unwrap_or(0);
+    std::env::temp_dir().join(format!("{prefix}-{}-{nanos}", std::process::id()))
+}
+
 fn expected_codes(source: &str) -> Vec<String> {
     let first_line = source.lines().next().unwrap_or_default();
     let Some(codes) = first_line.strip_prefix("// expect:") else {