Add rustc diagnostic remapping

Author: olwang

README.md

@@ -362,12 +362,26 @@ review map metadata
 Rust source lowering
 runtime crate type surface
 source map JSON for generated Rust packages
+rustc diagnostic remapping through source maps
 ```
 
 The first milestone is not a production runtime.
 
 The first milestone is a strong review-first checker that can validate the language model against real examples.
 
+Current CLI surface:
+
+```sh
+rss check [--json] <file.rss>
+rss check --explain <code>
+rss fmt <file.rss>
+rss review [--json] --diff <old.rss> <new.rss>
+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>
+```
+
 ---
 
 ## Roadmap

src/diagnostic.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 pub mod code {
     pub const MISSING_FILE_MODE: &str = "RS0001";
@@ -43,6 +43,8 @@ pub mod code {
     pub const IMPLICIT_CONVERSION_ATTEMPT: &str = "RS1002";
     pub const OWN_STRUCT_ATTEMPT: &str = "RS1003";
     pub const SURFACE_REFERENCE_ATTEMPT: &str = "RS1004";
+    pub const RUSTC_DIAGNOSTIC_MAPPED: &str = "RS1101";
+    pub const RUSTC_DIAGNOSTIC_UNMAPPABLE: &str = "RS1102";
 
     pub const REVIEW_MODE_CHANGED: &str = "RSR001";
     pub const REVIEW_FUNCTION_REMOVED: &str = "RSR002";
@@ -79,7 +81,7 @@ impl Severity {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Span {
     pub file: String,
     pub line: usize,
@@ -422,6 +424,16 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "surface reference attempt",
         explanation: "RSScript does not expose `&T` or `&mut T` syntax. Use explicit parameter effects such as `read`, `mut`, and `take`.",
     },
+    DiagnosticExplanation {
+        code: code::RUSTC_DIAGNOSTIC_MAPPED,
+        title: "mapped rustc diagnostic",
+        explanation: "A backend rustc diagnostic was translated through RSScript source-map metadata. Treat this as a compiler, runtime, native binding, or lowering issue unless the mapped RSScript source clearly violates the language rules.",
+    },
+    DiagnosticExplanation {
+        code: code::RUSTC_DIAGNOSTIC_UNMAPPABLE,
+        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.",
+    },
 ];
 
 pub fn format_diagnostics_json(diagnostics: &[Diagnostic]) -> String {

src/lib.rs

@@ -21,5 +21,6 @@ pub use review::{
 pub use rust_lower::{
     GeneratedRustPackage, LoweredRust, RustSourceMapEntry, 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,
+    lower_source_to_rust_with_map, parse_source_map_json, remap_rustc_diagnostic_json,
+    remap_rustc_diagnostic_json_lines,
 };

src/main.rs

@@ -7,7 +7,8 @@ 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, review_map_sources, review_sources,
+    lower_source_to_rust_package, parse_source_map_json, remap_rustc_diagnostic_json_lines,
+    review_map_sources, review_sources,
 };
 
 fn main() -> ExitCode {
@@ -22,6 +23,7 @@ fn main() -> ExitCode {
         "fmt" => run_fmt(&args[2..]),
         "review" => run_review(&args[2..]),
         "lower" => run_lower(&args[2..]),
+        "remap-rustc" => run_remap_rustc(&args[2..]),
         _ => {
             print_usage();
             ExitCode::from(2)
@@ -211,6 +213,63 @@ fn run_lower_rust_package(path: &str, source: &str, out_dir: &str) -> ExitCode {
     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 {
+        print_usage();
+        return ExitCode::from(2);
+    };
+
+    let source_map_json = match fs::read_to_string(source_map_path) {
+        Ok(source) => source,
+        Err(error) => {
+            eprintln!("failed to read {source_map_path}: {error}");
+            return ExitCode::from(2);
+        }
+    };
+    let rustc_json_lines = match fs::read_to_string(rustc_json_path) {
+        Ok(source) => source,
+        Err(error) => {
+            eprintln!("failed to read {rustc_json_path}: {error}");
+            return ExitCode::from(2);
+        }
+    };
+
+    let source_map = match parse_source_map_json(&source_map_json) {
+        Ok(source_map) => source_map,
+        Err(error) => {
+            eprintln!("{error}");
+            return ExitCode::from(2);
+        }
+    };
+    let remapped = match remap_rustc_diagnostic_json_lines(&source_map, &rustc_json_lines) {
+        Ok(remapped) => remapped,
+        Err(error) => {
+            eprintln!("{error}");
+            return ExitCode::from(2);
+        }
+    };
+    let diagnostics = remapped
+        .into_iter()
+        .map(|remapped| remapped.diagnostic)
+        .collect::<Vec<_>>();
+
+    if json {
+        println!("{}", format_diagnostics_json(&diagnostics));
+    } else {
+        print!("{}", format_diagnostics_human(&diagnostics));
+    }
+
+    if diagnostics
+        .iter()
+        .any(|diagnostic| diagnostic.severity.is_error())
+    {
+        ExitCode::from(1)
+    } else {
+        ExitCode::SUCCESS
+    }
+}
+
 fn parse_explain_args(args: &[String]) -> Option<&str> {
     let [flag, code] = args else {
         return None;
@@ -233,6 +292,21 @@ fn parse_path_args(args: &[String]) -> (bool, Option<&str>) {
     (json, path)
 }
 
+fn parse_multi_path_args(args: &[String]) -> (bool, Vec<&str>) {
+    let mut json = false;
+    let mut paths = Vec::new();
+
+    for arg in args {
+        if arg == "--json" {
+            json = true;
+        } else {
+            paths.push(arg.as_str());
+        }
+    }
+
+    (json, paths)
+}
+
 struct LowerOptions<'a> {
     emit_rust: bool,
     path: Option<&'a str>,
@@ -453,6 +527,7 @@ fn print_usage() {
     eprintln!("  rsscript fmt <file.rss>");
     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 review [--json] --diff <old.rss> <new.rss>");
     eprintln!("  rsscript review [--json] --map <file-or-directory>");
 }

src/rust_lower.rs

@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use crate::analyzer::analyze_source;
-use crate::diagnostic::{Diagnostic, Span};
+use crate::diagnostic::{Diagnostic, Severity, Span, code};
 use crate::syntax::ast::{
     BinaryOp, Block, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FileMode, FunctionDecl,
     GenericBound, GenericParam, Item, LetKind, Param, Program, Stmt, TypeDecl, TypeKind, TypeRef,
@@ -22,13 +22,19 @@ pub struct LoweredRust {
     pub source_map: Vec<RustSourceMapEntry>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct RustSourceMapEntry {
     pub kind: String,
     pub source: Span,
     pub generated: Span,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RemappedRustcDiagnostic {
+    pub diagnostic: Diagnostic,
+    pub mapped: bool,
+}
+
 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)
 }
@@ -80,6 +86,103 @@ pub fn lower_program_to_rust_with_map(program: &Program) -> LoweredRust {
     RustLowerer::new(program).lower()
 }
 
+pub fn parse_source_map_json(source_map_json: &str) -> Result<Vec<RustSourceMapEntry>, String> {
+    serde_json::from_str(source_map_json)
+        .map_err(|error| format!("failed to parse RSScript source map JSON: {error}"))
+}
+
+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)
+        .map_err(|error| format!("failed to parse rustc JSON diagnostic: {error}"))?;
+    if !matches!(rustc.level.as_str(), "error" | "warning") {
+        return Ok(None);
+    }
+
+    let rustc_span = rustc
+        .spans
+        .iter()
+        .find(|span| span.is_primary)
+        .or_else(|| rustc.spans.first());
+    let backend_code = rustc
+        .code
+        .as_ref()
+        .map(|code| code.code.as_str())
+        .unwrap_or("<none>");
+
+    if let Some(rustc_span) = rustc_span
+        && let Some(entry) = best_source_map_entry(
+            source_map,
+            &rustc_span.file_name,
+            rustc_span.line_start,
+            rustc_span.column_start,
+        )
+    {
+        let severity = rustc_severity(&rustc.level);
+        let summary = format!("backend diagnostic mapped to RSScript: {}", rustc.message);
+        let diagnostic = Diagnostic {
+            code: code::RUSTC_DIAGNOSTIC_MAPPED.to_string(),
+            severity,
+            summary,
+            span: entry.source.clone(),
+            label: "backend diagnostic maps to this RSScript construct".to_string(),
+            causes: vec![
+                format!("rustc code: {backend_code}"),
+                format!(
+                    "generated Rust: {}:{}:{}",
+                    rustc_span.file_name, rustc_span.line_start, rustc_span.column_start
+                ),
+                rustc.message,
+            ],
+            fixes: Vec::new(),
+        };
+        return Ok(Some(RemappedRustcDiagnostic {
+            diagnostic,
+            mapped: true,
+        }));
+    }
+
+    let generated = rustc_span
+        .map(generated_span_from_rustc)
+        .unwrap_or_else(|| Span {
+            file: "<rustc-json>".to_string(),
+            line: 1,
+            column: 1,
+            length: 1,
+        });
+    let diagnostic = Diagnostic {
+        code: code::RUSTC_DIAGNOSTIC_UNMAPPABLE.to_string(),
+        severity: rustc_severity(&rustc.level),
+        summary: format!("unmappable backend diagnostic: {}", rustc.message),
+        span: generated,
+        label: "generated Rust diagnostic could not be mapped to RSScript source".to_string(),
+        causes: vec![format!("rustc code: {backend_code}"), rustc.message],
+        fixes: Vec::new(),
+    };
+    Ok(Some(RemappedRustcDiagnostic {
+        diagnostic,
+        mapped: false,
+    }))
+}
+
+pub fn remap_rustc_diagnostic_json_lines(
+    source_map: &[RustSourceMapEntry],
+    rustc_json_lines: &str,
+) -> Result<Vec<RemappedRustcDiagnostic>, String> {
+    let mut diagnostics = Vec::new();
+    for line in rustc_json_lines
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+    {
+        if let Some(diagnostic) = remap_rustc_diagnostic_json(source_map, line)? {
+            diagnostics.push(diagnostic);
+        }
+    }
+    Ok(diagnostics)
+}
+
 struct RustLowerer<'a> {
     program: &'a Program,
     type_kinds: BTreeMap<String, TypeKind>,
@@ -589,6 +692,64 @@ fn stmt_span(statement: &Stmt) -> &Span {
     }
 }
 
+fn best_source_map_entry<'a>(
+    source_map: &'a [RustSourceMapEntry],
+    file: &str,
+    line: usize,
+    column: usize,
+) -> Option<&'a RustSourceMapEntry> {
+    source_map
+        .iter()
+        .filter(|entry| entry.generated.file == file)
+        .filter(|entry| generated_span_starts_before_or_at(&entry.generated, line, column))
+        .max_by_key(|entry| (entry.generated.line, entry.generated.column))
+}
+
+fn generated_span_starts_before_or_at(span: &Span, line: usize, column: usize) -> bool {
+    span.line < line || (span.line == line && span.column <= column)
+}
+
+fn rustc_severity(level: &str) -> Severity {
+    if level == "warning" {
+        Severity::Warning
+    } else {
+        Severity::Error
+    }
+}
+
+fn generated_span_from_rustc(span: &RustcJsonSpan) -> Span {
+    Span {
+        file: span.file_name.clone(),
+        line: span.line_start,
+        column: span.column_start,
+        length: span.column_end.saturating_sub(span.column_start).max(1),
+    }
+}
+
+#[derive(serde::Deserialize)]
+struct RustcJsonDiagnostic {
+    message: String,
+    level: String,
+    code: Option<RustcJsonCode>,
+    #[serde(default)]
+    spans: Vec<RustcJsonSpan>,
+}
+
+#[derive(serde::Deserialize)]
+struct RustcJsonCode {
+    code: String,
+}
+
+#[derive(serde::Deserialize)]
+struct RustcJsonSpan {
+    file_name: String,
+    line_start: usize,
+    column_start: usize,
+    column_end: usize,
+    #[serde(default)]
+    is_primary: bool,
+}
+
 fn push_source_marker(
     out: &mut String,
     indent: usize,