use std::collections::HashMap;
use std::io::BufRead;
use std::path::{Path, PathBuf};
use telar_project::{
EntryProblem, PreludeDeclaration, PreludeEntry, PreludeProblem, PreviewsIncludeProblem,
};
use telar_transpiler::{GeneratedSite, 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(),
}));
}
fn push(&mut self, item: Projected) {
let existing = self.projected.iter_mut().find(|p| {
p.source == item.source
&& p.line == item.line
&& p.underline == item.underline
&& p.level == item.level
&& p.message == item.message
});
match existing {
Some(existing) => {
for note in item.notes {
if !existing
.notes
.iter()
.any(|n| n.level == note.level && n.message == note.message)
{
existing.notes.push(note);
}
}
}
None => self.projected.push(item),
}
}
pub(crate) fn add_prelude_problems(&mut self, problems: &[PreludeProblem]) {
for problem in problems {
self.push(problem_frame(problem));
}
}
pub(crate) fn add_previews_include_problems(&mut self, problems: &[PreviewsIncludeProblem]) {
for problem in problems {
self.push(problem_frame(problem));
}
}
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 preludes: HashMap<PathBuf, PackagePrelude> = 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 prelude = preludes
.entry(origin.package_root.clone())
.or_insert_with(|| PackagePrelude::read(&origin.package_root));
let site = origin.site(span, line_start as u32);
if let Some(GeneratedSite::Glob(path)) = &site {
if let Some(projected) = prelude.unresolved(path, level, &text) {
report.push(projected);
mapped_any = true;
}
continue;
}
let Some((line, underline)) = origin.locate(span, line_start as u32) else {
continue;
};
let code = error_code(message);
let rewritten = site.as_ref().and_then(|site| {
let candidates = glob_candidates(message);
let rewritten =
telar_transpiler::tag_error_message(code, site, &prelude.entries, &candidates)?;
Some((site, rewritten))
});
let projected = match rewritten {
Some((GeneratedSite::Tag { tag, name }, rewritten)) => Projected {
source: origin.rsx_path.clone(),
line,
underline: origin.tag_underline(line, tag).or(underline),
level: level.to_string(),
message: rewritten,
notes: match code != "E0659" && tag_names(tag, name) {
true => notes_of(message),
false => Vec::new(),
},
},
_ => Projected {
source: origin.rsx_path.clone(),
line,
underline,
level: level.to_string(),
message: text.clone(),
notes: sigil_advice(message, notes_of(message)),
},
};
report.push(projected);
mapped_any = true;
}
if !mapped_any && !rendered.is_empty() {
report.passthrough.push(rendered);
}
}
report
}
fn error_code(message: &serde_json::Value) -> &str {
message
.get("code")
.and_then(|c| c.get("code"))
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
}
fn tag_names(tag: &str, name: &str) -> bool {
tag.rsplit("::").next() == Some(name)
}
fn glob_candidates(message: &serde_json::Value) -> Vec<String> {
let mut candidates: Vec<String> = Vec::new();
let children = message
.get("children")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten();
for span in children
.filter_map(|child| child.get("spans").and_then(serde_json::Value::as_array))
.flatten()
{
let Some(highlighted) = highlighted_text(span) else {
continue;
};
if let Some(path) = highlighted.strip_suffix("::*")
&& !candidates.iter().any(|known| known == path)
{
candidates.push(path.to_string());
}
}
candidates
}
fn highlighted_text(span: &serde_json::Value) -> Option<String> {
let first = span.get("text")?.as_array()?.first()?;
let line = first.get("text")?.as_str()?;
let from = first.get("highlight_start")?.as_u64()? as usize;
let to = first.get("highlight_end")?.as_u64()? as usize;
Some(
line.chars()
.skip(from.checked_sub(1)?)
.take(to.checked_sub(from)?)
.collect(),
)
}
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> {
if error_code(message) != "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 mut message = str_field(child, "message");
if message.is_empty() {
return None;
}
if let Some(replacement) = single_replacement(child) {
message.push_str(&format!(": `{replacement}`"));
}
Some(Note {
level: level.to_string(),
message,
})
})
.collect()
})
.unwrap_or_default()
}
fn single_replacement(child: &serde_json::Value) -> Option<String> {
let mut replacements = child
.get("spans")?
.as_array()?
.iter()
.filter_map(|span| span.get("suggested_replacement")?.as_str())
.map(str::trim);
let first = replacements.next()?;
let single = replacements.all(|other| other == first);
(single && !first.is_empty() && !first.contains('\n')).then(|| first.to_string())
}
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,
package_root: 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()?)?,
package_root: generated
.ancestors()
.find(|dir| dir.file_name() == Some(".telar".as_ref()))?
.parent()?
.to_path_buf(),
rsx_path,
})
}
fn site(&self, span: &serde_json::Value, line_start: u32) -> Option<GeneratedSite<'_>> {
let (start, end) = span_bytes(span)?;
if line_of(&self.generated, start) != Some(line_start as usize - 1) {
return None;
}
telar_transpiler::generated_site(&self.generated, start as usize, end as usize)
}
fn tag_underline(&self, line: usize, tag: &str) -> Option<(usize, usize)> {
let text = telar_transpiler::nth_line(&self.rsx_source, line.checked_sub(1)?)?;
let (from, to) = telar_transpiler::tag_columns(text, tag)?;
Some((text[..from].chars().count(), text[..to].chars().count()))
}
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)))))
}
}
}
}
struct PackagePrelude {
entries: Vec<PreludeEntry>,
declarations: Vec<PreludeDeclaration>,
problems: Vec<PreludeProblem>,
}
impl PackagePrelude {
fn read(package_root: &Path) -> Self {
let declarations = telar_project::prelude_declarations(package_root).unwrap_or_default();
Self {
entries: declarations.iter().map(|d| d.entry.clone()).collect(),
problems: telar_project::prelude_problems(package_root).unwrap_or_default(),
declarations,
}
}
fn unresolved(&self, path: &str, level: &str, rustc_message: &str) -> Option<Projected> {
if let Some(problem) = self
.problems
.iter()
.find(|problem| problem.declaration.entry.path() == path)
{
return Some(problem_frame(problem));
}
let declaration = self
.declarations
.iter()
.find(|declaration| declaration.entry.path() == path)?;
Some(Projected {
source: declaration.file.clone(),
line: declaration.line,
underline: Some(declaration.columns),
level: level.to_string(),
message: format!("`[telar] prelude` entry `{path}` does not resolve: {rustc_message}"),
notes: Vec::new(),
})
}
}
fn problem_frame<T>(problem: &EntryProblem<T>) -> Projected {
Projected {
source: problem.declaration.file.clone(),
line: problem.declaration.line,
underline: Some(problem.declaration.columns),
level: "error".to_string(),
message: problem.message.clone(),
notes: vec![Note {
level: "help".to_string(),
message: problem.help.clone(),
}],
}
}
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;