git.delta.rocks / jrsonnet / refs/commits / 0d591aa205cc

1mod location;23use crate::{error::Error, EvaluationState, LocError};4pub use location::*;5use std::path::PathBuf;67/// The way paths should be displayed8pub enum PathResolver {9	/// Only filename10	FileName,11	/// Absolute path12	Absolute,13	/// Path relative to base directory14	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}3435/// Implements pretty-printing of traces36pub 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	// fn print_trace(44	// 	&self,45	// 	evaluation_state: &EvaluationState,46	// 	error: &LocError,47	// ) -> Result<(), std::fmt::Error> {48	// 	self.write_trace(&mut std::fmt::stdout(), evaluation_state, error)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}7576/// vanilla-like jsonnet formatting77pub 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| el.location.as_ref().map(|l| {122				use std::fmt::Write;123				let mut resolved_path = self.resolver.resolve(&l.0);124				// TODO: Process all trace elements first125				let location = evaluation_state126					.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			.collect::<Vec<_>>();132		let align = file_names.iter().flatten().map(|e| e.len()).max().unwrap_or(0);133		for (i, (el, file)) in error.trace().0.iter().zip(file_names).enumerate() {134			if i != 0 {135				writeln!(out)?;136			}137			write!(138				out,139				"{:<p$}{:<w$}: {}",140				"",141				file.unwrap_or_else(|| "".to_owned()),142				el.desc,143				p = self.padding,144				w = align145			)?;146		}147		Ok(())148	}149}150151pub struct JSFormat;152impl TraceFormat for JSFormat {153	fn write_trace(154		&self,155		out: &mut dyn std::fmt::Write,156		evaluation_state: &EvaluationState,157		error: &LocError,158	) -> Result<(), std::fmt::Error> {159		writeln!(out, "{}", error.error())?;160		for (i, item) in error.trace().0.iter().enumerate() {161			if i != 0 {162				writeln!(out)?;163			}164			let desc = &item.desc;165			if let Some (source) = &item.location {166				let start_end = evaluation_state.map_source_locations(&source.0, &[source.1, source.2]);167168				write!(169					out,170					"    at {} ({}:{}:{})",171					desc,172					source.0.to_str().unwrap(),173					start_end[0].line,174					start_end[0].column,175				)?;176			} else {177				write!(178					out,179					"    at {}",180					desc,181				)?;182			}183		}184		Ok(())185	}186}187188/// rustc-like trace displaying189#[cfg(feature = "explaining-traces")]190pub struct ExplainingFormat {191	pub resolver: PathResolver,192}193#[cfg(feature = "explaining-traces")]194impl TraceFormat for ExplainingFormat {195	fn write_trace(196		&self,197		out: &mut dyn std::fmt::Write,198		evaluation_state: &EvaluationState,199		error: &LocError,200	) -> Result<(), std::fmt::Error> {201		writeln!(out, "{}", error.error())?;202		if let Error::ImportSyntaxError {203			path,204			source_code,205			error,206		} = error.error()207		{208			let mut offset = error.location.offset;209			if offset >= source_code.len() {210				offset = source_code.len() - 1;211			}212			let mut location = offset_to_location(source_code, &[offset])213				.into_iter()214				.next()215				.unwrap();216			if location.column >= 1 {217				location.column -= 1;218			}219220			self.print_snippet(221				out,222				source_code,223				path,224				&location,225				&location,226				"^ syntax error",227			)?;228		}229		let trace = &error.trace();230		for item in trace.0.iter() {231			let desc = &item.desc;232			if let Some(source) = &item.location {233				let start_end = evaluation_state.map_source_locations(&source.0, &[source.1, source.2]);234				self.print_snippet(235					out,236					&evaluation_state.get_source(&source.0).unwrap(),237					&source.0,238					&start_end[0],239					&start_end[1],240					desc,241				)?;242			} else {243				write!(out, "{}", desc)?;244			}245		}246		Ok(())247	}248}249250impl ExplainingFormat {251	fn print_snippet(252		&self,253		out: &mut dyn std::fmt::Write,254		source: &str,255		origin: &PathBuf,256		start: &CodeLocation,257		end: &CodeLocation,258		desc: &str,259	) -> Result<(), std::fmt::Error> {260		use annotate_snippets::{261			display_list::{DisplayList, FormatOptions},262			snippet::{AnnotationType, Slice, Snippet, SourceAnnotation},263		};264265		let source_fragment: String = source266			.chars()267			.skip(start.line_start_offset)268			.take(end.line_end_offset - end.line_start_offset)269			.collect();270271		let origin = self.resolver.resolve(origin);272		let snippet = Snippet {273			opt: FormatOptions {274				color: true,275				..Default::default()276			},277			title: None,278			footer: vec![],279			slices: vec![Slice {280				source: &source_fragment,281				line_start: start.line,282				origin: Some(&origin),283				fold: false,284				annotations: vec![SourceAnnotation {285					label: desc,286					annotation_type: AnnotationType::Error,287					range: (288						start.offset - start.line_start_offset,289						end.offset - start.line_start_offset,290					),291				}],292			}],293		};294295		let dl = DisplayList::from(snippet);296		writeln!(out, "{}", dl)?;297298		Ok(())299	}300}