git.delta.rocks / jrsonnet / refs/commits / 45caf79f1ab3

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| {122				el.location.as_ref().map(|l| {123					use std::fmt::Write;124					let mut resolved_path = self.resolver.resolve(&l.0);125					// TODO: Process all trace elements first126					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}190191/// rustc-like trace displaying192#[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}