1mod location;23use crate::{error::Error, EvaluationState, LocError};4pub use location::*;5use std::path::PathBuf;678pub enum PathResolver {9 10 FileName,11 12 Absolute,13 14 Relative(PathBuf),15}1617impl PathResolver {18 pub fn resolve(&self, from: &PathBuf) -> String {19 match self {20 Self::FileName => from.file_name().unwrap().to_string_lossy().into_owned(),21 Self::Absolute => from.to_string_lossy().into_owned(),22 Self::Relative(base) => {23 if from.is_relative() {24 return from.to_string_lossy().into_owned();25 }26 pathdiff::diff_paths(from, base)27 .unwrap()28 .to_string_lossy()29 .into_owned()30 }31 }32 }33}343536pub trait TraceFormat {37 fn write_trace(38 &self,39 out: &mut dyn std::fmt::Write,40 evaluation_state: &EvaluationState,41 error: &LocError,42 ) -> Result<(), std::fmt::Error>;43 44 45 46 47 48 49 50}5152fn print_code_location(53 out: &mut impl std::fmt::Write,54 start: &CodeLocation,55 end: &CodeLocation,56) -> Result<(), std::fmt::Error> {57 if start.line == end.line {58 if start.column == end.column {59 write!(out, "{}:{}", start.line, end.column - 1)?;60 } else {61 write!(out, "{}:{}-{}", start.line, start.column - 1, end.column)?;62 }63 } else {64 write!(65 out,66 "{}:{}-{}:{}",67 start.line,68 end.column.saturating_sub(1),69 start.line,70 end.column71 )?;72 }73 Ok(())74}757677pub struct CompactFormat {78 pub resolver: PathResolver,79 pub padding: usize,80}8182impl TraceFormat for CompactFormat {83 fn write_trace(84 &self,85 out: &mut dyn std::fmt::Write,86 evaluation_state: &EvaluationState,87 error: &LocError,88 ) -> Result<(), std::fmt::Error> {89 writeln!(out, "{}", error.error())?;90 if let Error::ImportSyntaxError {91 path,92 source_code,93 error,94 } = error.error()95 {96 use std::fmt::Write;97 let mut n = self.resolver.resolve(path);98 let mut offset = error.location.offset;99 let is_eof = if offset >= source_code.len() {100 offset = source_code.len() - 1;101 true102 } else {103 false104 };105 let mut location = offset_to_location(source_code, &[offset])106 .into_iter()107 .next()108 .unwrap();109 if is_eof {110 location.column += 1;111 }112113 write!(n, ":").unwrap();114 print_code_location(&mut n, &location, &location).unwrap();115 write!(out, "{:<p$}{}", "", n, p = self.padding,)?;116 }117 let file_names = error118 .trace()119 .0120 .iter()121 .map(|el| {122 el.location.as_ref().map(|l| {123 use std::fmt::Write;124 let mut resolved_path = self.resolver.resolve(&l.0);125 126 let location = evaluation_state.map_source_locations(&l.0, &[l.1, l.2]);127 write!(resolved_path, ":").unwrap();128 print_code_location(&mut resolved_path, &location[0], &location[1]).unwrap();129 resolved_path130 })131 })132 .collect::<Vec<_>>();133 let align = file_names134 .iter()135 .flatten()136 .map(|e| e.len())137 .max()138 .unwrap_or(0);139 for (i, (el, file)) in error.trace().0.iter().zip(file_names).enumerate() {140 if i != 0 {141 writeln!(out)?;142 }143 write!(144 out,145 "{:<p$}{:<w$}: {}",146 "",147 file.unwrap_or_else(|| "".to_owned()),148 el.desc,149 p = self.padding,150 w = align151 )?;152 }153 Ok(())154 }155}156157pub struct JSFormat;158impl TraceFormat for JSFormat {159 fn write_trace(160 &self,161 out: &mut dyn std::fmt::Write,162 evaluation_state: &EvaluationState,163 error: &LocError,164 ) -> Result<(), std::fmt::Error> {165 writeln!(out, "{}", error.error())?;166 for (i, item) in error.trace().0.iter().enumerate() {167 if i != 0 {168 writeln!(out)?;169 }170 let desc = &item.desc;171 if let Some(source) = &item.location {172 let start_end =173 evaluation_state.map_source_locations(&source.0, &[source.1, source.2]);174175 write!(176 out,177 " at {} ({}:{}:{})",178 desc,179 source.0.to_str().unwrap(),180 start_end[0].line,181 start_end[0].column,182 )?;183 } else {184 write!(out, " at {}", desc,)?;185 }186 }187 Ok(())188 }189}190191192#[cfg(feature = "explaining-traces")]193pub struct ExplainingFormat {194 pub resolver: PathResolver,195}196#[cfg(feature = "explaining-traces")]197impl TraceFormat for ExplainingFormat {198 fn write_trace(199 &self,200 out: &mut dyn std::fmt::Write,201 evaluation_state: &EvaluationState,202 error: &LocError,203 ) -> Result<(), std::fmt::Error> {204 writeln!(out, "{}", error.error())?;205 if let Error::ImportSyntaxError {206 path,207 source_code,208 error,209 } = error.error()210 {211 let mut offset = error.location.offset;212 if offset >= source_code.len() {213 offset = source_code.len() - 1;214 }215 let mut location = offset_to_location(source_code, &[offset])216 .into_iter()217 .next()218 .unwrap();219 if location.column >= 1 {220 location.column -= 1;221 }222223 self.print_snippet(224 out,225 source_code,226 path,227 &location,228 &location,229 "^ syntax error",230 )?;231 }232 let trace = &error.trace();233 for item in trace.0.iter() {234 let desc = &item.desc;235 if let Some(source) = &item.location {236 let start_end =237 evaluation_state.map_source_locations(&source.0, &[source.1, source.2]);238 self.print_snippet(239 out,240 &evaluation_state.get_source(&source.0).unwrap(),241 &source.0,242 &start_end[0],243 &start_end[1],244 desc,245 )?;246 } else {247 write!(out, "{}", desc)?;248 }249 }250 Ok(())251 }252}253254impl ExplainingFormat {255 fn print_snippet(256 &self,257 out: &mut dyn std::fmt::Write,258 source: &str,259 origin: &PathBuf,260 start: &CodeLocation,261 end: &CodeLocation,262 desc: &str,263 ) -> Result<(), std::fmt::Error> {264 use annotate_snippets::{265 display_list::{DisplayList, FormatOptions},266 snippet::{AnnotationType, Slice, Snippet, SourceAnnotation},267 };268269 let source_fragment: String = source270 .chars()271 .skip(start.line_start_offset)272 .take(end.line_end_offset - end.line_start_offset)273 .collect();274275 let origin = self.resolver.resolve(origin);276 let snippet = Snippet {277 opt: FormatOptions {278 color: true,279 ..Default::default()280 },281 title: None,282 footer: vec![],283 slices: vec![Slice {284 source: &source_fragment,285 line_start: start.line,286 origin: Some(&origin),287 fold: false,288 annotations: vec![SourceAnnotation {289 label: desc,290 annotation_type: AnnotationType::Error,291 range: (292 start.offset - start.line_start_offset,293 end.offset - start.line_start_offset,294 ),295 }],296 }],297 };298299 let dl = DisplayList::from(snippet);300 writeln!(out, "{}", dl)?;301302 Ok(())303 }304}