git.delta.rocks / jrsonnet / refs/commits / a31a8ef0c018

1use std::{2	cmp::Ordering,3	convert::Infallible,4	fmt::{Debug, Display},5	path::PathBuf,6};78use jrsonnet_gcmodule::Trace;9use jrsonnet_interner::IStr;10use jrsonnet_parser::{BinaryOpType, LocExpr, Source, SourcePath, Span, UnaryOpType};11use jrsonnet_types::ValType;12use thiserror::Error;1314use crate::{15	function::{builtin::ParamDefault, CallLocation},16	stdlib::format::FormatError,17	typed::TypeLocError,18	val::ConvertNumValueError,19	ObjValue,20};2122pub(crate) fn format_found(list: &[IStr], what: &str) -> String {23	if list.is_empty() {24		return String::new();25	}26	let mut out = String::new();27	out.push_str("\nThere ");28	if list.len() > 1 {29		out.push_str("are ");30	} else {31		out.push_str("is a ");32	}33	out.push_str(what);34	if list.len() > 1 {35		out.push('s');36	}37	out.push_str(" with similar name");38	if list.len() > 1 {39		out.push('s');40	}41	out.push_str(" present: ");42	for (i, v) in list.iter().enumerate() {43		if i != 0 {44			out.push_str(", ");45		}46		out.push_str(v as &str);47	}48	out49}5051fn format_signature(sig: &FunctionSignature) -> String {52	let mut out = String::new();53	out.push_str("\nFunction has the following signature: ");54	out.push('(');55	if sig.is_empty() {56		out.push_str("/*no arguments*/");57	} else {58		for (i, (name, default)) in sig.iter().enumerate() {59			if i != 0 {60				out.push_str(", ");61			}62			if let Some(name) = name {63				out.push_str(name);64			} else {65				out.push_str("<unnamed>");66			}67			match default {68				ParamDefault::None => {}69				ParamDefault::Exists => out.push_str(" = <default>"),70				ParamDefault::Literal(lit) => {71					out.push_str(" = ");72					out.push_str(lit);73				}74			}75		}76	}77	out.push(')');78	out79}8081const fn format_empty_str(str: &str) -> &str {82	if str.is_empty() {83		"\"\" (empty string)"84	} else {85		str86	}87}8889pub(crate) fn suggest_object_fields(v: &ObjValue, key: IStr) -> Vec<IStr> {90	let mut heap = Vec::new();91	for field in v.fields_ex(92		true,93		#[cfg(feature = "exp-preserve-order")]94		false,95	) {96		let conf = strsim::jaro_winkler(field.as_str(), key.as_str());97		if conf < 0.8 {98			continue;99		}100		assert!(field.as_str() != key.as_str(), "looks like string pooling failure, please write any info regarding this crash to https://github.com/CertainLach/jrsonnet/issues/113, thanks!");101102		heap.push((conf, field));103	}104	heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));105	heap.into_iter().map(|v| v.1).collect()106}107108type FunctionSignature = Vec<(Option<IStr>, ParamDefault)>;109110/// Possible errors111#[allow(missing_docs)]112#[derive(Error, Debug, Clone, Trace)]113#[non_exhaustive]114pub enum ErrorKind {115	#[error("intrinsic not found: {0}")]116	IntrinsicNotFound(IStr),117118	#[error("operator {0} does not operate on type {1}")]119	UnaryOperatorDoesNotOperateOnType(UnaryOpType, ValType),120	#[error("binary operation {1} {0} {2} is not implemented")]121	BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),122123	#[error("no top level object in this context")]124	NoTopLevelObjectFound,125	#[error("self is only usable inside objects")]126	CantUseSelfOutsideOfObject,127	#[error("no super found")]128	NoSuperFound,129130	#[error("for loop can only iterate over arrays")]131	InComprehensionCanOnlyIterateOverArray,132133	#[error("array out of bounds: {0} is not within [0,{1})")]134	ArrayBoundsError(isize, usize),135	#[error("string out of bounds: {0} is not within [0,{1})")]136	StringBoundsError(usize, usize),137138	#[error("assert failed: {}", format_empty_str(.0))]139	AssertionFailed(IStr),140141	#[error("local is not defined: {0}{}", format_found(.1, "local"))]142	VariableIsNotDefined(IStr, Vec<IStr>),143	#[error("duplicate local var: {0}")]144	DuplicateLocalVar(IStr),145146	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{e}")).collect::<Vec<_>>().join(", "))]147	TypeMismatch(&'static str, Vec<ValType>, ValType),148	#[error("no such field: {}{}", format_empty_str(.0), format_found(.1, "field"))]149	NoSuchField(IStr, Vec<IStr>),150151	#[error("only functions can be called, got {0}")]152	OnlyFunctionsCanBeCalledGot(ValType),153	#[error("parameter {0} is not defined")]154	UnknownFunctionParameter(String),155	#[error("argument {0} is already bound")]156	BindingParameterASecondTime(IStr),157	#[error("too many args, function has {0}{}", format_signature(.1))]158	TooManyArgsFunctionHas(usize, FunctionSignature),159	#[error("function argument is not passed: {}{}", .0.as_ref().map_or("<unnamed>", IStr::as_str), format_signature(.1))]160	FunctionParameterNotBoundInCall(Option<IStr>, FunctionSignature),161162	#[error("external variable is not defined: {0}")]163	UndefinedExternalVariable(IStr),164165	#[error("field name should be string, got {0}")]166	FieldMustBeStringGot(ValType),167	#[error("duplicate field name: {}", format_empty_str(.0))]168	DuplicateFieldName(IStr),169170	#[error("attempted to index array with string {}", format_empty_str(.0))]171	AttemptedIndexAnArrayWithString(IStr),172	#[error("{0} index type should be {1}, got {2}")]173	ValueIndexMustBeTypeGot(ValType, ValType, ValType),174	#[error("cant index into {0}")]175	CantIndexInto(ValType),176	#[error("{0} is not indexable")]177	ValueIsNotIndexable(ValType),178179	#[error("super can't be used standalone")]180	StandaloneSuper,181182	#[error("can't resolve {1} from {0}")]183	ImportFileNotFound(SourcePath, String),184	#[error("can't resolve absolute {0}")]185	AbsoluteImportFileNotFound(PathBuf),186	#[error("resolved file not found: {:?}", .0)]187	ResolvedFileNotFound(SourcePath),188	#[error("can't import {0}: is a directory")]189	ImportIsADirectory(SourcePath),190	#[error("imported file is not valid utf-8: {0:?}")]191	ImportBadFileUtf8(SourcePath),192	#[error("import io error: {0}")]193	ImportIo(String),194	#[error("tried to import {1} from {0}, but imports are not supported")]195	ImportNotSupported(SourcePath, String),196	#[error("tried to import {0}, but absolute imports are not supported")]197	AbsoluteImportNotSupported(PathBuf),198	#[error("can't import from virtual file")]199	CantImportFromVirtualFile,200	#[error(201		"syntax error: {}",202		// Peg has no fancier way to handle critical parsing errors https://github.com/kevinmehall/rust-peg/issues/225203		{.error.expected.tokens().find(|t| t.starts_with("!!!")).map_or_else(|| {204			format!(205				"expected {}, got {:?}",206				.error.expected,207				.path.code().chars().nth(error.location.offset)208				.map_or_else(|| "EOF".into(), |c| c.to_string())209			)210		}, |v| v[3..].into())}211	)]212	ImportSyntaxError {213		path: Source,214		#[trace(skip)]215		error: Box<jrsonnet_parser::ParseError>,216	},217218	#[error("runtime error: {}", format_empty_str(.0))]219	RuntimeError(IStr),220	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]221	StackOverflow,222	#[error("infinite recursion detected")]223	InfiniteRecursionDetected,224	#[error("tried to index by fractional value")]225	FractionalIndex,226	#[error("attempted to divide by zero")]227	DivisionByZero,228229	#[error("string manifest output is not an string")]230	StringManifestOutputIsNotAString,231	#[error("stream manifest output is not an array")]232	StreamManifestOutputIsNotAArray,233	#[error("multi manifest output is not an object")]234	MultiManifestOutputIsNotAObject,235236	#[error("cant recurse stream manifest")]237	StreamManifestOutputCannotBeRecursed,238	#[error("stream manifest output cannot consist of raw strings")]239	StreamManifestCannotNestString,240241	#[error("{}", format_empty_str(.0))]242	ImportCallbackError(String),243	#[error("invalid unicode codepoint: {0}")]244	InvalidUnicodeCodepointGot(u32),245246	#[error("convert num value: {0}")]247	ConvertNumValue(#[from] ConvertNumValueError),248249	#[error("format error: {0}")]250	Format(#[from] FormatError),251	#[error("type error: {0}")]252	TypeError(TypeLocError),253254	#[cfg(feature = "anyhow-error")]255	#[error(transparent)]256	Other(#[trace(skip)] std::rc::Rc<anyhow::Error>),257}258259#[cfg(feature = "anyhow-error")]260impl From<anyhow::Error> for Error {261	fn from(e: anyhow::Error) -> Self {262		Self::new(ErrorKind::Other(std::rc::Rc::new(e)))263	}264}265266impl From<ErrorKind> for Error {267	fn from(e: ErrorKind) -> Self {268		Self::new(e)269	}270}271272impl From<Infallible> for Error {273	fn from(_value: Infallible) -> Self {274		unreachable!()275	}276}277278/// Single stack trace frame279#[derive(Clone, Debug, Trace)]280pub struct StackTraceElement {281	/// Source of this frame282	/// Some frames only act as description, without attached source283	pub location: Option<Span>,284	/// Frame description285	pub desc: String,286}287#[derive(Debug, Clone, Trace)]288pub struct StackTrace(pub Vec<StackTraceElement>);289290#[derive(Clone, Trace)]291pub struct Error(Box<(ErrorKind, StackTrace)>);292impl Error {293	pub fn new(e: ErrorKind) -> Self {294		Self(Box::new((e, StackTrace(vec![]))))295	}296297	pub const fn error(&self) -> &ErrorKind {298		&(self.0).0299	}300	pub fn error_mut(&mut self) -> &mut ErrorKind {301		&mut (self.0).0302	}303	pub const fn trace(&self) -> &StackTrace {304		&(self.0).1305	}306	pub fn trace_mut(&mut self) -> &mut StackTrace {307		&mut (self.0).1308	}309}310impl Display for Error {311	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {312		writeln!(f, "{}", self.0 .0)?;313		for el in &self.0 .1 .0 {314			write!(f, "\t{}", el.desc)?;315			if let Some(loc) = &el.location {316				write!(f, "at {}", loc.0 .0 .0)?;317				loc.0.map_source_locations(&[loc.1, loc.2]);318			}319			writeln!(f)?;320		}321		Ok(())322	}323}324impl Debug for Error {325	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {326		f.debug_tuple("LocError").field(&self.0).finish()327	}328}329impl std::error::Error for Error {}330331pub trait ErrorSource {332	fn to_location(self) -> Option<Span>;333}334impl ErrorSource for &LocExpr {335	fn to_location(self) -> Option<Span> {336		Some(self.span())337	}338}339impl ErrorSource for &Span {340	fn to_location(self) -> Option<Span> {341		Some(self.clone())342	}343}344impl ErrorSource for CallLocation<'_> {345	fn to_location(self) -> Option<Span> {346		self.0.cloned()347	}348}349350pub type Result<V, E = Error> = std::result::Result<V, E>;351pub trait ResultExt: Sized {352	#[must_use]353	fn with_description<O: Into<String>>(self, msg: impl FnOnce() -> O) -> Self;354	#[must_use]355	fn description(self, msg: &str) -> Self {356		self.with_description(|| msg)357	}358359	#[must_use]360	fn with_description_src<O: Into<String>>(361		self,362		src: impl ErrorSource,363		msg: impl FnOnce() -> O,364	) -> Self;365	#[must_use]366	fn description_src(self, src: impl ErrorSource, msg: &str) -> Self {367		self.with_description_src(src, || msg)368	}369}370impl<T> ResultExt for Result<T, Error> {371	fn with_description<O: Into<String>>(mut self, msg: impl FnOnce() -> O) -> Self {372		if let Err(e) = &mut self {373			let trace = e.trace_mut();374			trace.0.push(StackTraceElement {375				location: None,376				desc: msg().into(),377			});378		}379		self380	}381382	fn with_description_src<O: Into<String>>(383		mut self,384		src: impl ErrorSource,385		msg: impl FnOnce() -> O,386	) -> Self {387		if let Err(e) = &mut self {388			let trace = e.trace_mut();389			trace.0.push(StackTraceElement {390				location: src.to_location(),391				desc: msg().into(),392			});393		}394		self395	}396}397398#[macro_export]399macro_rules! bail {400	($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {401		return Err($w$(::$i)*$(($($tt)*))?.into())402	};403	($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {404		return Err($w$(::$i)*$({$($tt)*})?.into())405	};406	($l:literal$(, $($tt:tt)*)?) => {407		return Err($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())408	};409}410411#[macro_export]412macro_rules! runtime_error {413	($l:literal$(, $($tt:tt)*)?) => {414		$crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))415	};416}