use std::borrow::Cow;
use std::collections::HashMap;
use std::fmt;
use std::fmt::Display;
use std::fmt::Write as _;
use std::path::PathBuf;
use deno_terminal::colors;
use unicode_width::UnicodeWidthStr;
use crate::ModuleSpecifier;
use crate::SourcePos;
use crate::SourceRange;
use crate::SourceRanged;
use crate::SourceTextInfo;
pub enum DiagnosticLevel {
Error,
Warning,
}
#[derive(Clone, Copy, Debug)]
pub struct DiagnosticSourceRange {
pub start: DiagnosticSourcePos,
pub end: DiagnosticSourcePos,
}
#[derive(Clone, Copy, Debug)]
pub enum DiagnosticSourcePos {
SourcePos(SourcePos),
ByteIndex(usize),
LineAndCol {
line: usize,
column: usize,
},
}
impl DiagnosticSourcePos {
fn pos(&self, source: &SourceTextInfo) -> SourcePos {
match self {
DiagnosticSourcePos::SourcePos(pos) => *pos,
DiagnosticSourcePos::ByteIndex(index) => source.range().start() + *index,
DiagnosticSourcePos::LineAndCol { line, column } => {
source.line_start(*line) + *column
}
}
}
}
#[derive(Clone, Debug)]
pub enum DiagnosticLocation<'a> {
Path { path: PathBuf },
Module {
specifier: Cow<'a, ModuleSpecifier>,
},
ModulePosition {
specifier: Cow<'a, ModuleSpecifier>,
source_pos: DiagnosticSourcePos,
text_info: Cow<'a, SourceTextInfo>,
},
}
impl<'a> DiagnosticLocation<'a> {
fn position(&self) -> Option<(usize, usize)> {
match self {
DiagnosticLocation::Path { .. } => None,
DiagnosticLocation::Module { .. } => None,
DiagnosticLocation::ModulePosition {
specifier: _specifier,
source_pos,
text_info,
} => {
let pos = source_pos.pos(text_info);
let line_index = text_info.line_index(pos);
let line_start_pos = text_info.line_start(line_index);
let content =
text_info.range_text(&SourceRange::new(line_start_pos, pos));
let line = line_index + 1;
let column = content.encode_utf16().count() + 1;
Some((line, column))
}
}
}
}
pub struct DiagnosticSnippet<'a> {
pub source: Cow<'a, crate::SourceTextInfo>,
pub highlights: Vec<DiagnosticSnippetHighlight<'a>>,
}
#[derive(Clone)]
pub struct DiagnosticSnippetHighlight<'a> {
pub range: DiagnosticSourceRange,
pub style: DiagnosticSnippetHighlightStyle,
pub description: Option<Cow<'a, str>>,
}
#[derive(Clone, Copy)]
pub enum DiagnosticSnippetHighlightStyle {
Error,
#[allow(dead_code)]
Warning,
#[allow(dead_code)]
Hint,
}
impl DiagnosticSnippetHighlightStyle {
fn style_underline(
&self,
s: impl std::fmt::Display,
) -> impl std::fmt::Display {
match self {
DiagnosticSnippetHighlightStyle::Error => colors::red_bold(s),
DiagnosticSnippetHighlightStyle::Warning => colors::yellow_bold(s),
DiagnosticSnippetHighlightStyle::Hint => colors::intense_blue(s),
}
}
fn underline_char(&self) -> char {
match self {
DiagnosticSnippetHighlightStyle::Error => '^',
DiagnosticSnippetHighlightStyle::Warning => '^',
DiagnosticSnippetHighlightStyle::Hint => '-',
}
}
}
fn line_text(source: &SourceTextInfo, line_number: usize) -> &str {
source.line_text(line_number - 1)
}
fn line_number(source: &SourceTextInfo, pos: DiagnosticSourcePos) -> usize {
source.line_index(pos.pos(source)) + 1
}
pub trait Diagnostic {
fn level(&self) -> DiagnosticLevel;
fn code(&self) -> Cow<'_, str>;
fn message(&self) -> Cow<'_, str>;
fn location(&self) -> DiagnosticLocation;
fn snippet(&self) -> Option<DiagnosticSnippet<'_>>;
fn hint(&self) -> Option<Cow<'_, str>>;
fn snippet_fixed(&self) -> Option<DiagnosticSnippet<'_>>;
fn info(&self) -> Cow<'_, [Cow<'_, str>]>;
fn docs_url(&self) -> Option<Cow<'_, str>>;
fn display(&self) -> DiagnosticDisplay<Self> {
DiagnosticDisplay { diagnostic: self }
}
}
struct RepeatingCharFmt(char, usize);
impl fmt::Display for RepeatingCharFmt {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for _ in 0..self.1 {
f.write_char(self.0)?;
}
Ok(())
}
}
const TAB_WIDTH: usize = 2;
struct ReplaceTab<'a>(&'a str);
impl fmt::Display for ReplaceTab<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut written = 0;
for (i, c) in self.0.char_indices() {
if c == '\t' {
self.0[written..i].fmt(f)?;
RepeatingCharFmt(' ', TAB_WIDTH).fmt(f)?;
written = i + 1;
}
}
self.0[written..].fmt(f)?;
Ok(())
}
}
fn display_width(str: &str) -> usize {
str.width_cjk() + (str.chars().filter(|c| *c == '\t').count() * TAB_WIDTH)
}
pub struct DiagnosticDisplay<'a, T: Diagnostic + ?Sized> {
diagnostic: &'a T,
}
impl<T: Diagnostic + ?Sized> Display for DiagnosticDisplay<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
print_diagnostic(f, self.diagnostic)
}
}
fn print_diagnostic(
io: &mut dyn std::fmt::Write,
diagnostic: &(impl Diagnostic + ?Sized),
) -> Result<(), std::fmt::Error> {
match diagnostic.level() {
DiagnosticLevel::Error => {
write!(
io,
"{}",
colors::red_bold(format_args!("error[{}]", diagnostic.code()))
)?;
}
DiagnosticLevel::Warning => {
write!(
io,
"{}",
colors::yellow_bold(format_args!("warning[{}]", diagnostic.code()))
)?;
}
}
writeln!(io, ": {}", colors::bold(diagnostic.message()))?;
let mut max_line_number_digits = 1;
if let Some(snippet) = diagnostic.snippet() {
for highlight in snippet.highlights.iter() {
let last_line = line_number(&snippet.source, highlight.range.end);
max_line_number_digits =
max_line_number_digits.max(last_line.ilog10() + 1);
}
}
if let Some(snippet) = diagnostic.snippet_fixed() {
for highlight in snippet.highlights.iter() {
let last_line = line_number(&snippet.source, highlight.range.end);
max_line_number_digits =
max_line_number_digits.max(last_line.ilog10() + 1);
}
}
let location = diagnostic.location();
write!(
io,
"{}{}",
RepeatingCharFmt(' ', max_line_number_digits as usize),
colors::intense_blue("-->"),
)?;
match &location {
DiagnosticLocation::Path { path } => {
write!(io, " {}", colors::cyan(path.display()))?;
}
DiagnosticLocation::Module { specifier }
| DiagnosticLocation::ModulePosition { specifier, .. } => {
if let Some(path) = specifier_to_file_path(specifier) {
write!(io, " {}", colors::cyan(path.display()))?;
} else {
write!(io, " {}", colors::cyan(specifier.as_str()))?;
}
}
}
if let Some((line, column)) = location.position() {
write!(
io,
"{}",
colors::yellow(format_args!(":{}:{}", line, column))
)?;
}
if diagnostic.snippet().is_some()
|| diagnostic.hint().is_some()
|| diagnostic.snippet_fixed().is_some()
|| !diagnostic.info().is_empty()
|| diagnostic.docs_url().is_some()
{
writeln!(io)?;
}
if let Some(snippet) = diagnostic.snippet() {
print_snippet(io, &snippet, max_line_number_digits)?;
};
if let Some(hint) = diagnostic.hint() {
write!(
io,
"{} {} ",
RepeatingCharFmt(' ', max_line_number_digits as usize),
colors::intense_blue("=")
)?;
writeln!(io, "{}: {}", colors::bold("hint"), hint)?;
}
if let Some(snippet) = diagnostic.snippet_fixed() {
print_snippet(io, &snippet, max_line_number_digits)?;
}
if !diagnostic.info().is_empty() || diagnostic.docs_url().is_some() {
writeln!(io)?;
}
for info in diagnostic.info().iter() {
writeln!(io, " {}: {}", colors::intense_blue("info"), info)?;
}
if let Some(docs_url) = diagnostic.docs_url() {
writeln!(io, " {}: {}", colors::intense_blue("docs"), docs_url)?;
}
Ok(())
}
fn print_snippet(
io: &mut dyn std::fmt::Write,
snippet: &DiagnosticSnippet<'_>,
max_line_number_digits: u32,
) -> Result<(), std::fmt::Error> {
let DiagnosticSnippet { source, highlights } = snippet;
fn print_padded(
io: &mut dyn std::fmt::Write,
text: impl std::fmt::Display,
padding: u32,
) -> Result<(), std::fmt::Error> {
for _ in 0..padding {
write!(io, " ")?;
}
write!(io, "{}", text)?;
Ok(())
}
let mut lines_to_show = HashMap::<usize, Vec<usize>>::new();
let mut highlights_info = Vec::new();
for (i, highlight) in highlights.iter().enumerate() {
let start_line_number = line_number(source, highlight.range.start);
let end_line_number = line_number(source, highlight.range.end);
highlights_info.push((start_line_number, end_line_number));
for line_number in start_line_number..=end_line_number {
lines_to_show.entry(line_number).or_default().push(i);
}
}
let mut lines_to_show = lines_to_show.into_iter().collect::<Vec<_>>();
lines_to_show.sort();
print_padded(io, colors::intense_blue(" | "), max_line_number_digits)?;
writeln!(io)?;
let mut previous_line_number = None;
let mut previous_line_empty = false;
for (line_number, highlight_indexes) in lines_to_show {
if previous_line_number.is_some()
&& previous_line_number == Some(line_number - 1)
&& !previous_line_empty
{
print_padded(io, colors::intense_blue(" | "), max_line_number_digits)?;
writeln!(io)?;
}
print_padded(
io,
colors::intense_blue(format_args!("{} | ", line_number)),
max_line_number_digits - line_number.ilog10() - 1,
)?;
let line_start_pos = source.line_start(line_number - 1);
let line_end_pos = source.line_end(line_number - 1);
let line_text = line_text(source, line_number);
writeln!(io, "{}", ReplaceTab(line_text))?;
previous_line_empty = false;
let mut wrote_description = false;
for highlight_index in highlight_indexes {
let highlight = &highlights[highlight_index];
let (start_line_number, end_line_number) =
highlights_info[highlight_index];
let padding_width;
let highlight_width;
if start_line_number == end_line_number {
padding_width = display_width(source.range_text(&SourceRange::new(
line_start_pos,
highlight.range.start.pos(source),
)));
highlight_width = display_width(source.range_text(&SourceRange::new(
highlight.range.start.pos(source),
highlight.range.end.pos(source),
)));
} else if start_line_number == line_number {
padding_width = display_width(source.range_text(&SourceRange::new(
line_start_pos,
highlight.range.start.pos(source),
)));
highlight_width = display_width(source.range_text(&SourceRange::new(
highlight.range.start.pos(source),
line_end_pos,
)));
} else if end_line_number == line_number {
padding_width = 0;
highlight_width = display_width(source.range_text(&SourceRange::new(
line_start_pos,
highlight.range.end.pos(source),
)));
} else {
padding_width = 0;
highlight_width = display_width(line_text);
}
let underline =
RepeatingCharFmt(highlight.style.underline_char(), highlight_width);
print_padded(io, colors::intense_blue(" | "), max_line_number_digits)?;
write!(io, "{}", RepeatingCharFmt(' ', padding_width))?;
write!(io, "{}", highlight.style.style_underline(underline))?;
if line_number == end_line_number {
if let Some(description) = &highlight.description {
write!(io, " {}", highlight.style.style_underline(description))?;
wrote_description = true;
}
}
writeln!(io)?;
}
if wrote_description {
print_padded(io, colors::intense_blue(" | "), max_line_number_digits)?;
writeln!(io)?;
previous_line_empty = true;
}
previous_line_number = Some(line_number);
}
Ok(())
}
fn specifier_to_file_path(specifier: &ModuleSpecifier) -> Option<PathBuf> {
fn to_file_path_if_not_wasm(_specifier: &ModuleSpecifier) -> Option<PathBuf> {
#[cfg(target_arch = "wasm32")]
{
None
}
#[cfg(not(target_arch = "wasm32"))]
{
_specifier.to_file_path().ok()
}
}
if specifier.scheme() != "file" {
None
} else if cfg!(windows) {
match to_file_path_if_not_wasm(specifier) {
Some(path) => Some(path),
None => {
if specifier.scheme() == "file"
&& specifier.host().is_none()
&& specifier.port().is_none()
&& specifier.path_segments().is_some()
{
let path_str = specifier.path();
match String::from_utf8(
percent_encoding::percent_decode(path_str.as_bytes()).collect(),
) {
Ok(path_str) => Some(PathBuf::from(path_str)),
Err(_) => None,
}
} else {
None
}
}
}
} else {
to_file_path_if_not_wasm(specifier)
}
}
#[cfg(test)]
mod tests {
use std::borrow::Cow;
use super::*;
use crate::ModuleSpecifier;
use crate::SourceTextInfo;
#[test]
fn test_display_width() {
assert_eq!(display_width("abc"), 3);
assert_eq!(display_width("\t"), 2);
assert_eq!(display_width("\t\t123"), 7);
assert_eq!(display_width("π"), 2);
assert_eq!(display_width("ππ"), 4);
assert_eq!(display_width("π§βπ¦°"), 4);
}
#[test]
fn test_position_in_file_from_text_info_simple() {
let specifier: ModuleSpecifier = "file:///dev/test.ts".parse().unwrap();
let text_info = SourceTextInfo::new("foo\nbar\nbaz".into());
let pos = text_info.line_start(1);
let location = DiagnosticLocation::ModulePosition {
specifier: Cow::Borrowed(&specifier),
source_pos: DiagnosticSourcePos::SourcePos(pos),
text_info: Cow::Owned(text_info),
};
let position = location.position().unwrap();
assert_eq!(position, (2, 1))
}
#[test]
fn test_position_in_file_from_text_info_emoji() {
let specifier: ModuleSpecifier = "file:///dev/test.ts".parse().unwrap();
let text_info = SourceTextInfo::new("π§βπ¦°text".into());
let pos = text_info.line_start(0) + 11; let location = DiagnosticLocation::ModulePosition {
specifier: Cow::Borrowed(&specifier),
source_pos: DiagnosticSourcePos::SourcePos(pos),
text_info: Cow::Owned(text_info),
};
let position = location.position().unwrap();
assert_eq!(position, (1, 6))
}
#[test]
fn test_specifier_to_file_path() {
run_success_test("file:///", "/");
run_success_test("file:///test", "/test");
run_success_test("file:///dir/test/test.txt", "/dir/test/test.txt");
run_success_test(
"file:///dir/test%20test/test.txt",
"/dir/test test/test.txt",
);
fn run_success_test(specifier: &str, expected_path: &str) {
let result =
specifier_to_file_path(&ModuleSpecifier::parse(specifier).unwrap())
.unwrap();
assert_eq!(result, PathBuf::from(expected_path));
}
}
}