1#[cfg(feature = "explaining-traces")]2use std::cell::RefCell;3use std::{4 any::Any,5 path::{Path, PathBuf},6};78use jrsonnet_gcmodule::Trace;9use jrsonnet_parser::CodeLocation;10#[cfg(feature = "explaining-traces")]11use jrsonnet_parser::Span;1213use crate::{error::ErrorKind, Error};141516#[derive(Clone, Trace)]17pub enum PathResolver {18 19 FileName,20 21 Absolute,22 23 Relative(PathBuf),24}2526impl PathResolver {27 28 pub fn new_cwd_fallback() -> Self {29 std::env::current_dir().map_or(Self::Absolute, Self::Relative)30 }31 pub fn resolve(&self, from: &Path) -> String {32 match self {33 Self::FileName => from34 .file_name()35 .expect("file name exists")36 .to_string_lossy()37 .into_owned(),38 Self::Absolute => from.to_string_lossy().into_owned(),39 Self::Relative(base) => {40 if from.is_relative() {41 return from.to_string_lossy().into_owned();42 }43 pathdiff::diff_paths(from, base)44 .expect("base is absolute")45 .to_string_lossy()46 .into_owned()47 }48 }49 }50}515253#[allow(clippy::module_name_repetitions)]54pub trait TraceFormat: Trace {55 fn write_trace(56 &self,57 out: &mut dyn std::fmt::Write,58 error: &Error,59 ) -> Result<(), std::fmt::Error>;60 fn format(&self, error: &Error) -> Result<String, std::fmt::Error> {61 let mut out = String::new();62 self.write_trace(&mut out, error)?;63 Ok(out)64 }65 fn as_any(&self) -> &dyn Any;66 fn as_any_mut(&mut self) -> &mut dyn Any;67}6869fn print_code_location(70 out: &mut impl std::fmt::Write,71 start: &CodeLocation,72 end: &CodeLocation,73) -> Result<(), std::fmt::Error> {74 if start.line == end.line {75 if start.column == end.column {76 write!(out, "{}:{}", start.line, end.column.saturating_sub(1))?;77 } else {78 write!(out, "{}:{}-{}", start.line, start.column - 1, end.column)?;79 }80 } else {81 write!(82 out,83 "{}:{}-{}:{}",84 start.line,85 end.column.saturating_sub(1),86 start.line,87 end.column88 )?;89 }90 Ok(())91}929394#[derive(Trace)]95pub struct CompactFormat {96 pub resolver: PathResolver,97 pub max_trace: usize,98 pub padding: usize,99}100impl Default for CompactFormat {101 fn default() -> Self {102 Self {103 resolver: PathResolver::Absolute,104 max_trace: 20,105 padding: 4,106 }107 }108}109110impl TraceFormat for CompactFormat {111 fn write_trace(112 &self,113 out: &mut dyn std::fmt::Write,114 error: &Error,115 ) -> Result<(), std::fmt::Error> {116 write!(out, "{}", error.error())?;117 if let ErrorKind::ImportSyntaxError { path, error } = error.error() {118 use std::fmt::Write;119120 writeln!(out)?;121 let mut n = path.source_path().path().map_or_else(122 || path.source_path().to_string(),123 |r| self.resolver.resolve(r),124 );125 let mut offset = error.location.offset;126 let is_eof = if offset >= path.code().len() {127 offset = path.code().len().saturating_sub(1);128 true129 } else {130 false131 };132 let mut location = path133 .map_source_locations(&[offset as u32])134 .into_iter()135 .next()136 .unwrap();137 if is_eof {138 location.column += 1;139 }140141 write!(n, ":").unwrap();142 print_code_location(&mut n, &location, &location).unwrap();143 write!(out, "{:<p$}{n}", "", p = self.padding)?;144 }145 let file_names = error146 .trace()147 .0148 .iter()149 .map(|el| &el.location)150 .map(|location| {151 use std::fmt::Write;152 #[allow(clippy::option_if_let_else)]153 if let Some(location) = location {154 let mut resolved_path = match location.0.source_path().path() {155 Some(r) => self.resolver.resolve(r),156 None => location.0.source_path().to_string(),157 };158 159 let location = location.0.map_source_locations(&[location.1, location.2]);160 write!(resolved_path, ":").unwrap();161 print_code_location(&mut resolved_path, &location[0], &location[1]).unwrap();162 write!(resolved_path, ":").unwrap();163 Some(resolved_path)164 } else {165 None166 }167 })168 .collect::<Vec<_>>();169 let align = file_names170 .iter()171 .flatten()172 .map(String::len)173 .max()174 .unwrap_or(0);175 for (el, file) in error.trace().0.iter().zip(file_names) {176 writeln!(out)?;177 if let Some(file) = file {178 write!(179 out,180 "{:<p$}{:<w$} {}",181 "",182 file,183 el.desc,184 p = self.padding,185 w = align186 )?;187 } else {188 write!(out, "{:<p$}{}", "", el.desc, p = self.padding,)?;189 }190 }191 Ok(())192 }193194 fn as_any(&self) -> &dyn Any {195 self196 }197198 fn as_any_mut(&mut self) -> &mut dyn Any {199 self200 }201}202203#[derive(Trace)]204pub struct JsFormat {205 pub max_trace: usize,206}207impl TraceFormat for JsFormat {208 fn write_trace(209 &self,210 out: &mut dyn std::fmt::Write,211 error: &Error,212 ) -> Result<(), std::fmt::Error> {213 write!(out, "{}", error.error())?;214 for item in &error.trace().0 {215 writeln!(out)?;216 let desc = &item.desc;217 if let Some(source) = &item.location {218 let start_end = source.0.map_source_locations(&[source.1, source.2]);219 let resolved_path = source.0.source_path().path().map_or_else(220 || source.0.source_path().to_string(),221 |r| r.display().to_string(),222 );223224 write!(225 out,226 " at {} ({}:{}:{})",227 desc, resolved_path, start_end[0].line, start_end[0].column,228 )?;229 } else {230 write!(out, " during {desc}")?;231 }232 }233 Ok(())234 }235236 fn as_any(&self) -> &dyn Any {237 self238 }239240 fn as_any_mut(&mut self) -> &mut dyn Any {241 self242 }243}244245#[cfg(feature = "explaining-traces")]246#[derive(Trace)]247pub struct HiDocFormat {248 pub resolver: PathResolver,249 pub max_trace: usize,250}251#[cfg(feature = "explaining-traces")]252impl TraceFormat for HiDocFormat {253 fn write_trace(254 &self,255 out: &mut dyn std::fmt::Write,256 error: &Error,257 ) -> Result<(), std::fmt::Error> {258 struct ResetData {259 loc: Span,260 }261 use hi_doc::{source_to_ansi, Formatting, SnippetBuilder, Text};262263 write!(out, "{}", error.error())?;264 if let ErrorKind::ImportSyntaxError { path, error } = error.error() {265 writeln!(out)?;266 let offset = error.location.offset;267 let mut builder = SnippetBuilder::new(path.code());268 builder269 .error(Text::fragment("syntax error", Formatting::default()))270 .range(offset..=offset)271 .build();272 let source = builder.build();273 let ansi = source_to_ansi(&source);274 write!(out, "{ansi}")?;275 }276 let trace = &error.trace();277 let snippet_builder: RefCell<Option<SnippetBuilder>> = RefCell::new(None);278 let mut last_location: Option<Span> = None;279 let mut flush_builder = |data: Option<ResetData>| {280 use std::fmt::Write;281 let mut out = String::new();282 let location_changed = if let Some(ResetData { loc }) = &data {283 if last_location.as_ref().map(|l| l.0.code()) != Some(loc.0.code()) {284 true285 } else if let (Some(last), new) = (&last_location, loc) {286 287 last.1 > new.1 || last.2 > new.2288 } else {289 false290 }291 } else {292 true293 };294 if location_changed {295 if let Some(builder) = snippet_builder.borrow_mut().take() {296 let rendered = builder.build();297 let ansi = source_to_ansi(&rendered);298 if let Some(loc) = &last_location {299 let _ = writeln!(out, "...at {}", loc.0.source_path());300 }301 let _ = write!(out, "{}", ansi.trim_end());302 }303 last_location = None;304305 if let Some(ResetData { loc }) = data {306 *snippet_builder.borrow_mut() = Some(SnippetBuilder::new(loc.0.code()));307 last_location = Some(loc);308 }309 }310 if out.is_empty() {311 return None;312 }313 Some(out)314 };315 for item in &trace.0 {316 let desc = &item.desc;317 if let Some(source) = &item.location {318 if let Some(flushed) = flush_builder(Some(ResetData {319 loc: source.clone(),320 })) {321 writeln!(out)?;322 write!(out, "{flushed}")?;323 }324 let mut builder = snippet_builder.borrow_mut();325 let builder = builder.as_mut().unwrap();326 builder327 .note(Text::fragment(desc, Formatting::default()))328 .range(source.1 as usize..=(source.2 as usize - 1).max(source.1 as usize))329 .build();330 } else {331 if let Some(flushed) = flush_builder(None) {332 writeln!(out)?;333 write!(out, "{flushed}")?;334 }335 writeln!(out)?;336 write!(out, " {desc}")?;337 }338 }339340 if let Some(flushed) = flush_builder(None) {341 writeln!(out)?;342 write!(out, "{flushed}")?;343 }344 Ok(())345 }346347 fn as_any(&self) -> &dyn Any {348 self349 }350351 fn as_any_mut(&mut self) -> &mut dyn Any {352 self353 }354}