use std::collections::HashMap;
use std::io::BufRead;
use std::path::{Path, PathBuf};
use telar_transpiler::{RsxSpan, SourceMap};
pub(crate) struct Note {
level: String,
message: String,
}
pub(crate) struct Projected {
source: PathBuf,
line: usize,
underline: Option<(usize, usize)>,
level: String,
message: String,
notes: Vec<Note>,
}
#[derive(Default)]
pub(crate) struct Report {
projected: Vec<Projected>,
passthrough: Vec<String>,
}
impl Report {
pub(crate) fn add_semantic(
&mut self,
source: &std::path::Path,
diagnostics: Vec<telar_diagnostics::Diagnostic>,
) {
self.projected
.extend(diagnostics.into_iter().map(|d| Projected {
source: source.to_path_buf(),
line: d.span.line,
underline: None,
level: match d.severity {
telar_diagnostics::Severity::Error => "error".to_string(),
telar_diagnostics::Severity::Warning => "warning".to_string(),
},
message: d.message,
notes: Vec::new(),
}));
}
pub(crate) fn is_empty(&self) -> bool {
self.projected.is_empty() && self.passthrough.is_empty()
}
pub(crate) fn has_errors(&self) -> bool {
self.projected.iter().any(|p| p.level == "error")
}
pub(crate) fn render(&self, color: bool) -> String {
let mut out = String::new();
let mut sources: HashMap<PathBuf, Option<Vec<String>>> = HashMap::new();
for item in &self.projected {
let lines = sources
.entry(item.source.clone())
.or_insert_with(|| read_lines(&item.source));
item.render_into(&mut out, lines.as_deref(), color);
}
for rendered in &self.passthrough {
match color {
true => out.push_str(rendered),
false => out.push_str(&strip_ansi(rendered)),
}
}
out
}
}
impl Projected {
fn render_into(&self, out: &mut String, source_lines: Option<&[String]>, color: bool) {
let paint = |code: &str, text: &str| match color {
true => format!("\x1b[{code}m{text}\x1b[0m"),
false => text.to_string(),
};
let level_color = if self.level == "error" {
"1;31"
} else {
"1;33"
};
let number = self.line.to_string();
let gutter = " ".repeat(number.len());
out.push_str(&paint(level_color, &self.level));
out.push_str(&paint("1", ": "));
out.push_str(&paint("1", &self.message));
out.push('\n');
out.push_str(&format!(
"{gutter}{} {}:{}\n",
paint("1;34", "-->"),
display(&self.source),
self.line
));
if let Some(text) = source_lines.and_then(|lines| lines.get(self.line - 1)) {
let bar = paint("1;34", "|");
out.push_str(&format!("{gutter} {bar}\n"));
out.push_str(&format!(
"{} {bar} {}\n",
paint("1;34", &number),
text.trim_end()
));
match self.underline {
Some((start, end)) => out.push_str(&format!(
"{gutter} {bar} {}{}\n",
" ".repeat(start),
paint(level_color, &"^".repeat(end.saturating_sub(start).max(1)))
)),
None => out.push_str(&format!("{gutter} {bar}\n")),
}
}
for note in &self.notes {
let mut lines = note.message.lines();
out.push_str(&format!(
"{gutter} {} {}: {}\n",
paint("1;34", "="),
paint("1", ¬e.level),
lines.next().unwrap_or_default()
));
for line in lines {
out.push_str(&format!("{gutter} {line}\n"));
}
}
out.push('\n');
}
}
pub(crate) fn collect(reader: impl BufRead) -> Report {
let mut origins: HashMap<PathBuf, Option<Origin>> = HashMap::new();
let mut report = Report::default();
for line in reader.lines().map_while(Result::ok) {
let Ok(value) = serde_json::from_str::<serde_json::Value>(&line) else {
continue;
};
if value.get("reason").and_then(serde_json::Value::as_str) != Some("compiler-message") {
continue;
}
let Some(message) = value.get("message") else {
continue;
};
let level = message
.get("level")
.and_then(serde_json::Value::as_str)
.unwrap_or("error");
if level != "error" && level != "warning" {
continue;
}
let text = str_field(message, "message");
let rendered = str_field(message, "rendered");
let mut mapped_any = false;
for span in primary_spans(message) {
let Some(file) = span.get("file_name").and_then(serde_json::Value::as_str) else {
continue;
};
let generated = PathBuf::from(file);
if !telar_project::is_generated_output(&generated) {
continue;
}
let Some(line_start) = span.get("line_start").and_then(serde_json::Value::as_u64)
else {
continue;
};
let origin = origins
.entry(generated.clone())
.or_insert_with(|| Origin::read(&generated));
let Some(origin) = origin.as_ref() else {
continue;
};
let Some((line, underline)) = origin.locate(span, line_start as u32) else {
continue;
};
report.projected.push(Projected {
source: origin.rsx_path.clone(),
line,
underline,
level: level.to_string(),
message: text.clone(),
notes: sigil_advice(message, notes_of(message)),
});
mapped_any = true;
}
if !mapped_any && !rendered.is_empty() {
report.passthrough.push(rendered);
}
}
report
}
fn str_field(message: &serde_json::Value, key: &str) -> String {
message
.get(key)
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
.to_string()
}
fn sigil_advice(message: &serde_json::Value, notes: Vec<Note>) -> Vec<Note> {
let code = message
.get("code")
.and_then(|c| c.get("code"))
.and_then(serde_json::Value::as_str)
.unwrap_or_default();
if code != "E0382" {
return notes;
}
let mut notes: Vec<Note> = notes
.into_iter()
.filter(|n| !n.message.contains("cloning the value"))
.collect();
notes.push(Note {
level: "help".to_string(),
message:
"mark it with the sigil — `$name` — so each closure that captures it gets its own copy"
.to_string(),
});
notes
}
fn notes_of(message: &serde_json::Value) -> Vec<Note> {
message
.get("children")
.and_then(serde_json::Value::as_array)
.map(|children| {
children
.iter()
.filter_map(|child| {
let level = child.get("level").and_then(serde_json::Value::as_str)?;
if level != "help" && level != "note" {
return None;
}
let message = str_field(child, "message");
(!message.is_empty()).then(|| Note {
level: level.to_string(),
message,
})
})
.collect()
})
.unwrap_or_default()
}
fn primary_spans(message: &serde_json::Value) -> Vec<&serde_json::Value> {
message
.get("spans")
.and_then(serde_json::Value::as_array)
.map(|spans| {
spans
.iter()
.filter(|span| {
span.get("is_primary")
.and_then(serde_json::Value::as_bool)
.unwrap_or(false)
})
.collect()
})
.unwrap_or_default()
}
struct Origin {
rsx_path: PathBuf,
rsx_source: String,
generated: String,
map: SourceMap,
}
impl Origin {
fn read(generated: &Path) -> Option<Self> {
let rsx_path = telar_project::source_for_generated(generated)?;
let mut map_path = generated.as_os_str().to_os_string();
map_path.push(".map");
Some(Self {
rsx_source: std::fs::read_to_string(&rsx_path).ok()?,
generated: std::fs::read_to_string(generated).ok()?,
map: SourceMap::from_json(&std::fs::read_to_string(PathBuf::from(map_path)).ok()?)?,
rsx_path,
})
}
fn locate(
&self,
span: &serde_json::Value,
line_start: u32,
) -> Option<(usize, Option<(usize, usize)>)> {
let by_line = |line: u32| Some((line as usize + 1, None));
let Some((byte_start, byte_end)) = span_bytes(span) else {
return by_line((*self.map.lines.get(line_start as usize - 1)?)?);
};
if line_of(&self.generated, byte_start) != Some(line_start as usize - 1) {
return by_line((*self.map.lines.get(line_start as usize - 1)?)?);
}
match self
.map
.locate(&self.generated, byte_start, byte_end, &self.rsx_source)?
{
RsxSpan::Line(line) => by_line(line),
RsxSpan::Exact { start, end } => {
let line = line_of(&self.rsx_source, start)?;
let text = telar_transpiler::nth_line(&self.rsx_source, line)?;
let from = column_of(&self.rsx_source, start);
let to = match line_of(&self.rsx_source, end) == Some(line) {
true => column_of(&self.rsx_source, end),
false => text.len(),
};
let chars_to = |at: usize| text[..at.min(text.len())].chars().count();
Some((line + 1, Some((chars_to(from), chars_to(to)))))
}
}
}
}
fn span_bytes(span: &serde_json::Value) -> Option<(u32, u32)> {
let at = |key| span.get(key).and_then(serde_json::Value::as_u64);
Some((at("byte_start")? as u32, at("byte_end")? as u32))
}
fn line_of(text: &str, offset: u32) -> Option<usize> {
let offset = offset as usize;
(offset <= text.len()).then(|| text[..offset].matches('\n').count())
}
fn column_of(text: &str, offset: u32) -> usize {
let offset = (offset as usize).min(text.len());
offset - text[..offset].rfind('\n').map_or(0, |at| at + 1)
}
fn read_lines(source: &Path) -> Option<Vec<String>> {
std::fs::read_to_string(source)
.ok()
.map(|text| text.lines().map(str::to_string).collect())
}
fn display(path: &Path) -> String {
std::env::current_dir()
.ok()
.and_then(|cwd| path.strip_prefix(cwd).ok().map(Path::to_path_buf))
.unwrap_or_else(|| path.to_path_buf())
.display()
.to_string()
}
fn strip_ansi(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut chars = text.chars();
while let Some(c) = chars.next() {
if c != '\x1b' {
out.push(c);
continue;
}
if chars.next() != Some('[') {
continue;
}
for c in chars.by_ref() {
if c.is_ascii_alphabetic() {
break;
}
}
}
out
}
#[cfg(test)]
#[path = "diagnostics_test.rs"]
mod tests;