mirror of https://github.com/zkat/miette.git
419 lines
16 KiB
Rust
419 lines
16 KiB
Rust
use std::fmt;
|
|
|
|
use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
|
|
|
|
use crate::diagnostic_chain::DiagnosticChain;
|
|
use crate::protocol::{Diagnostic, Severity};
|
|
use crate::{LabeledSpan, MietteError, ReportHandler, SourceCode, SourceSpan, SpanContents};
|
|
|
|
/**
|
|
[`ReportHandler`] that renders plain text and avoids extraneous graphics.
|
|
It's optimized for screen readers and braille users, but is also used in any
|
|
non-graphical environments, such as non-TTY output.
|
|
*/
|
|
#[derive(Debug, Clone)]
|
|
pub struct NarratableReportHandler {
|
|
context_lines: Option<usize>,
|
|
with_cause_chain: bool,
|
|
footer: Option<String>,
|
|
}
|
|
|
|
impl NarratableReportHandler {
|
|
/// Create a new [`NarratableReportHandler`]. There are no customization
|
|
/// options.
|
|
pub const fn new() -> Self {
|
|
Self {
|
|
footer: None,
|
|
context_lines: Some(1),
|
|
with_cause_chain: true,
|
|
}
|
|
}
|
|
|
|
/// Include the cause chain of the top-level error in the report, if
|
|
/// available.
|
|
pub const fn with_cause_chain(mut self) -> Self {
|
|
self.with_cause_chain = true;
|
|
self
|
|
}
|
|
|
|
/// Do not include the cause chain of the top-level error in the report.
|
|
pub const fn without_cause_chain(mut self) -> Self {
|
|
self.with_cause_chain = false;
|
|
self
|
|
}
|
|
|
|
/// Set the footer to be displayed at the end of the report.
|
|
pub fn with_footer(mut self, footer: String) -> Self {
|
|
self.footer = Some(footer);
|
|
self
|
|
}
|
|
|
|
/// Sets the number of lines of context to show around each error.
|
|
///
|
|
/// If `0`, then only the span content will be shown (equivalent to
|
|
/// `with_opt_context_lines(None)`).\
|
|
/// Use `with_opt_context_lines(Some(0))` if you want the whole line
|
|
/// containing the error without extra context.
|
|
pub fn with_context_lines(self, lines: usize) -> Self {
|
|
self.with_opt_context_lines((lines != 0).then_some(lines))
|
|
}
|
|
|
|
/// Sets the number of lines of context to show around each error.
|
|
///
|
|
/// `None` means only the span content (and possibly the content in between
|
|
/// multiple adjacent labels) will be shown.\
|
|
/// `Some(0)` will show the whole line containing the label.\
|
|
/// `Some(n)` will show the whole line plus n line before and after the label.
|
|
pub fn with_opt_context_lines(mut self, lines: Option<usize>) -> Self {
|
|
self.context_lines = lines;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Default for NarratableReportHandler {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl NarratableReportHandler {
|
|
/// Render a [`Diagnostic`]. This function is mostly internal and meant to
|
|
/// be called by the toplevel [`ReportHandler`] handler, but is
|
|
/// made public to make it easier (possible) to test in isolation from
|
|
/// global state.
|
|
pub fn render_report(
|
|
&self,
|
|
f: &mut impl fmt::Write,
|
|
diagnostic: &(dyn Diagnostic),
|
|
) -> fmt::Result {
|
|
self.render_header(f, diagnostic)?;
|
|
if self.with_cause_chain {
|
|
self.render_causes(f, diagnostic)?;
|
|
}
|
|
let src = diagnostic.source_code();
|
|
self.render_snippets(f, diagnostic, src)?;
|
|
self.render_footer(f, diagnostic)?;
|
|
self.render_related(f, diagnostic, src)?;
|
|
if let Some(footer) = &self.footer {
|
|
writeln!(f, "{}", footer)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn render_header(&self, f: &mut impl fmt::Write, diagnostic: &(dyn Diagnostic)) -> fmt::Result {
|
|
writeln!(f, "{}", diagnostic)?;
|
|
let severity = match diagnostic.severity() {
|
|
Some(Severity::Error) | None => "error",
|
|
Some(Severity::Warning) => "warning",
|
|
Some(Severity::Advice) => "advice",
|
|
};
|
|
writeln!(f, " Diagnostic severity: {}", severity)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn render_causes(&self, f: &mut impl fmt::Write, diagnostic: &(dyn Diagnostic)) -> fmt::Result {
|
|
if let Some(cause_iter) = diagnostic
|
|
.diagnostic_source()
|
|
.map(DiagnosticChain::from_diagnostic)
|
|
.or_else(|| diagnostic.source().map(DiagnosticChain::from_stderror))
|
|
{
|
|
for error in cause_iter {
|
|
writeln!(f, " Caused by: {}", error)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn render_footer(&self, f: &mut impl fmt::Write, diagnostic: &(dyn Diagnostic)) -> fmt::Result {
|
|
if let Some(help) = diagnostic.help() {
|
|
writeln!(f, "diagnostic help: {}", help)?;
|
|
}
|
|
if let Some(code) = diagnostic.code() {
|
|
writeln!(f, "diagnostic code: {}", code)?;
|
|
}
|
|
if let Some(url) = diagnostic.url() {
|
|
writeln!(f, "For more details, see:\n{}", url)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn render_related(
|
|
&self,
|
|
f: &mut impl fmt::Write,
|
|
diagnostic: &(dyn Diagnostic),
|
|
parent_src: Option<&dyn SourceCode>,
|
|
) -> fmt::Result {
|
|
if let Some(related) = diagnostic.related() {
|
|
writeln!(f)?;
|
|
for rel in related {
|
|
match rel.severity() {
|
|
Some(Severity::Error) | None => write!(f, "Error: ")?,
|
|
Some(Severity::Warning) => write!(f, "Warning: ")?,
|
|
Some(Severity::Advice) => write!(f, "Advice: ")?,
|
|
};
|
|
self.render_header(f, rel)?;
|
|
writeln!(f)?;
|
|
self.render_causes(f, rel)?;
|
|
let src = rel.source_code().or(parent_src);
|
|
self.render_snippets(f, rel, src)?;
|
|
self.render_footer(f, rel)?;
|
|
self.render_related(f, rel, src)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn render_snippets(
|
|
&self,
|
|
f: &mut impl fmt::Write,
|
|
diagnostic: &(dyn Diagnostic),
|
|
source_code: Option<&dyn SourceCode>,
|
|
) -> fmt::Result {
|
|
if let Some(source) = source_code {
|
|
if let Some(labels) = diagnostic.labels() {
|
|
let mut labels = labels.collect::<Vec<_>>();
|
|
labels.sort_unstable_by_key(|l| l.inner().offset());
|
|
if !labels.is_empty() {
|
|
let contents = labels
|
|
.iter()
|
|
.map(|label| {
|
|
source.read_span(label.inner(), self.context_lines, self.context_lines)
|
|
})
|
|
.collect::<Result<Vec<Box<dyn SpanContents<'_>>>, MietteError>>()
|
|
.map_err(|_| fmt::Error)?;
|
|
let mut contexts = Vec::new();
|
|
for (right, right_conts) in labels.iter().cloned().zip(contents.iter()) {
|
|
if contexts.is_empty() {
|
|
contexts.push((right, right_conts));
|
|
} else {
|
|
let (left, left_conts) = contexts.last().unwrap().clone();
|
|
let left_end = left.offset() + left.len();
|
|
let right_end = right.offset() + right.len();
|
|
if left_conts.line() + left_conts.line_count() >= right_conts.line() {
|
|
// The snippets will overlap, so we create one Big Chunky Boi
|
|
let new_span = LabeledSpan::new(
|
|
left.label().map(String::from),
|
|
left.offset(),
|
|
if right_end >= left_end {
|
|
// Right end goes past left end
|
|
right_end - left.offset()
|
|
} else {
|
|
// right is contained inside left
|
|
left.len()
|
|
},
|
|
);
|
|
if source
|
|
.read_span(
|
|
new_span.inner(),
|
|
self.context_lines,
|
|
self.context_lines,
|
|
)
|
|
.is_ok()
|
|
{
|
|
contexts.pop();
|
|
contexts.push((
|
|
new_span, // We'll throw this away later
|
|
left_conts,
|
|
));
|
|
} else {
|
|
contexts.push((right, right_conts));
|
|
}
|
|
} else {
|
|
contexts.push((right, right_conts));
|
|
}
|
|
}
|
|
}
|
|
for (ctx, _) in contexts {
|
|
self.render_context(f, source, &ctx, &labels[..])?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn render_context(
|
|
&self,
|
|
f: &mut impl fmt::Write,
|
|
source: &dyn SourceCode,
|
|
context: &LabeledSpan,
|
|
labels: &[LabeledSpan],
|
|
) -> fmt::Result {
|
|
let (contents, lines) = self.get_lines(source, context.inner())?;
|
|
write!(f, "Begin snippet")?;
|
|
if let Some(filename) = contents.name() {
|
|
write!(f, " for {}", filename,)?;
|
|
}
|
|
writeln!(
|
|
f,
|
|
" starting at line {}, column {}",
|
|
contents.line() + 1,
|
|
contents.column() + 1
|
|
)?;
|
|
writeln!(f)?;
|
|
for line in &lines {
|
|
writeln!(f, "snippet line {}: {}", line.line_number, line.text)?;
|
|
let relevant = labels
|
|
.iter()
|
|
.filter_map(|l| line.span_attach(l.inner()).map(|a| (a, l)));
|
|
for (attach, label) in relevant {
|
|
match attach {
|
|
SpanAttach::Contained { col_start, col_end } if col_start == col_end => {
|
|
write!(
|
|
f,
|
|
" label at line {}, column {}",
|
|
line.line_number, col_start,
|
|
)?;
|
|
}
|
|
SpanAttach::Contained { col_start, col_end } => {
|
|
write!(
|
|
f,
|
|
" label at line {}, columns {} to {}",
|
|
line.line_number, col_start, col_end,
|
|
)?;
|
|
}
|
|
SpanAttach::Starts { col_start } => {
|
|
write!(
|
|
f,
|
|
" label starting at line {}, column {}",
|
|
line.line_number, col_start,
|
|
)?;
|
|
}
|
|
SpanAttach::Ends { col_end } => {
|
|
write!(
|
|
f,
|
|
" label ending at line {}, column {}",
|
|
line.line_number, col_end,
|
|
)?;
|
|
}
|
|
}
|
|
if let Some(label) = label.label() {
|
|
write!(f, ": {}", label)?;
|
|
}
|
|
writeln!(f)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn get_lines<'a>(
|
|
&'a self,
|
|
source: &'a dyn SourceCode,
|
|
context_span: &'a SourceSpan,
|
|
) -> Result<(Box<dyn SpanContents<'a> + 'a>, Vec<Line>), fmt::Error> {
|
|
let context_data = source
|
|
.read_span(context_span, self.context_lines, self.context_lines)
|
|
.map_err(|_| fmt::Error)?;
|
|
let context = std::str::from_utf8(context_data.data()).expect("Bad utf8 detected");
|
|
|
|
let lines = context
|
|
.split_inclusive('\n')
|
|
.enumerate()
|
|
.map(|(line_number, line)| {
|
|
// SAFETY:
|
|
// - it is safe to use `offset_from` on slices of an array per Rus design (max array size)
|
|
// (https://doc.rust-lang.org/stable/reference/types/numeric.html#machine-dependent-integer-types)
|
|
// - since `line` is a slice of `context`, the offset cannot be negative either
|
|
let offset = unsafe { line.as_ptr().offset_from(context.as_ptr()) } as usize;
|
|
let length = line.len();
|
|
// Strip the newline chars
|
|
let line = line
|
|
.strip_suffix('\n')
|
|
.and_then(|line| line.strip_suffix('\r').or(Some(line)))
|
|
.unwrap_or(line);
|
|
// End of the "file" if the end of the line is also the end of
|
|
// the context and we removed some characters (newline)
|
|
let at_end_of_file = (offset + length == context.len()) && (length != line.len());
|
|
Line {
|
|
line_number: context_data.line() + line_number + 1,
|
|
offset: context_data.span().offset() + offset,
|
|
text: line.to_string(),
|
|
at_end_of_file,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Ok((context_data, lines))
|
|
}
|
|
}
|
|
|
|
impl ReportHandler for NarratableReportHandler {
|
|
fn debug(&self, diagnostic: &(dyn Diagnostic), f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
if f.alternate() {
|
|
return fmt::Debug::fmt(diagnostic, f);
|
|
}
|
|
|
|
self.render_report(f, diagnostic)
|
|
}
|
|
}
|
|
|
|
/*
|
|
Support types
|
|
*/
|
|
|
|
struct Line {
|
|
line_number: usize,
|
|
offset: usize,
|
|
text: String,
|
|
at_end_of_file: bool,
|
|
}
|
|
|
|
enum SpanAttach {
|
|
Contained { col_start: usize, col_end: usize },
|
|
Starts { col_start: usize },
|
|
Ends { col_end: usize },
|
|
}
|
|
|
|
/// Returns column at offset, and nearest boundary if offset is in the middle of
|
|
/// the character
|
|
fn safe_get_column(text: &str, offset: usize, start: bool) -> usize {
|
|
let mut column = text.get(0..offset).map(|s| s.width()).unwrap_or_else(|| {
|
|
let mut column = 0;
|
|
for (idx, c) in text.char_indices() {
|
|
if offset <= idx {
|
|
break;
|
|
}
|
|
column += c.width().unwrap_or(0);
|
|
}
|
|
column
|
|
});
|
|
if start {
|
|
// Offset are zero-based, so plus one
|
|
column += 1;
|
|
} // On the other hand for end span, offset refers for the next column
|
|
// So we should do -1. column+1-1 == column
|
|
column
|
|
}
|
|
|
|
impl Line {
|
|
fn span_attach(&self, span: &SourceSpan) -> Option<SpanAttach> {
|
|
let span_end = span.offset() + span.len();
|
|
let line_end = self.offset + self.text.len();
|
|
|
|
let start_after = span.offset() >= self.offset;
|
|
let end_before = self.at_end_of_file || span_end <= line_end;
|
|
|
|
if start_after && end_before {
|
|
let col_start = safe_get_column(&self.text, span.offset() - self.offset, true);
|
|
let col_end = if span.is_empty() {
|
|
col_start
|
|
} else {
|
|
// span_end refers to the next character after token
|
|
// while col_end refers to the exact character, so -1
|
|
safe_get_column(&self.text, span_end - self.offset, false)
|
|
};
|
|
return Some(SpanAttach::Contained { col_start, col_end });
|
|
}
|
|
if start_after && span.offset() <= line_end {
|
|
let col_start = safe_get_column(&self.text, span.offset() - self.offset, true);
|
|
return Some(SpanAttach::Starts { col_start });
|
|
}
|
|
if end_before && span_end >= self.offset {
|
|
let col_end = safe_get_column(&self.text, span_end - self.offset, false);
|
|
return Some(SpanAttach::Ends { col_end });
|
|
}
|
|
None
|
|
}
|
|
}
|