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

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -13,8 +13,9 @@
 };
 
 use jrsonnet_evaluator::{
+	bail,
 	error::{ErrorKind::*, Result},
-	throw, FileImportResolver, ImportResolver,
+	FileImportResolver, ImportResolver,
 };
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
@@ -80,7 +81,7 @@
 		assert!(success == 0 || success == 1);
 		if success == 0 {
 			let result = String::from_utf8(buf_intern).expect("error should be valid string");
-			throw!(ImportCallbackError(result));
+			bail!(ImportCallbackError(result));
 		}
 
 		let found_here_raw = unsafe { CStr::from_ptr(found_here) };

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -19,12 +19,12 @@
 };
 
 use jrsonnet_evaluator::{
-	apply_tla,
+	apply_tla, bail,
 	function::TlaArg,
 	gc::GcHashMap,
 	manifest::{JsonFormat, ManifestFormat, ToStringFormat},
 	stack::set_stack_depth_limit,
-	tb, throw,
+	tb,
 	trace::{CompactFormat, PathResolver, TraceFormat},
 	FileImportResolver, IStr, Result, State, Val,
 };
@@ -249,7 +249,7 @@
 
 fn val_to_multi(val: Val, format: &dyn ManifestFormat) -> Result<Vec<(IStr, IStr)>> {
 	let Val::Obj(val) = val else {
-		throw!("expected object as multi output")
+		bail!("expected object as multi output")
 	};
 	let mut out = Vec::new();
 	for (k, v) in val.iter(
@@ -336,7 +336,7 @@
 
 fn val_to_stream(val: Val, format: &dyn ManifestFormat) -> Result<Vec<IStr>> {
 	let Val::Arr(val) = val else {
-		throw!("expected array as stream output")
+		bail!("expected array as stream output")
 	};
 	let mut out = Vec::new();
 	for item in val.iter() {

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -7,9 +7,9 @@
 use clap_complete::Shell;
 use jrsonnet_cli::{GcOpts, ManifestOpts, MiscOpts, OutputOpts, StdOpts, TlaOpts, TraceOpts};
 use jrsonnet_evaluator::{
-	apply_tla,
+	apply_tla, bail,
 	error::{Error as JrError, ErrorKind},
-	throw, ResultExt, State, Val,
+	ResultExt, State, Val,
 };
 
 #[cfg(feature = "mimalloc")]
@@ -208,7 +208,7 @@
 			create_dir_all(dir)?;
 		}
 		let Val::Obj(obj) = val else {
-			throw!(
+			bail!(
 				"value should be object for --multi manifest, got {}",
 				val.value_type()
 			)

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -54,7 +54,7 @@
 	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {
 		use std::cmp::Ordering;
 
-		use crate::throw;
+		use crate::bail;
 
 		if let Some(val) = self.0.bindings.get(&name).cloned() {
 			return Ok(val);
@@ -70,7 +70,7 @@
 		});
 		heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));
 
-		throw!(VariableIsNotDefined(
+		bail!(VariableIsNotDefined(
 			name,
 			heap.into_iter().map(|(_, k)| k).collect()
 		))

--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -2,7 +2,7 @@
 
 use jrsonnet_gcmodule::{Cc, Trace};
 
-use crate::{error::ErrorKind::InfiniteRecursionDetected, throw, val::ThunkValue, Result, Thunk};
+use crate::{bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue, Result};
 
 // TODO: Replace with OnceCell once in std
 #[derive(Clone, Trace)]
@@ -41,7 +41,7 @@
 
 	fn get(self: Box<Self>) -> Result<Self::Output> {
 		let Some(value) = self.0.get() else {
-			throw!(InfiniteRecursionDetected);
+			bail!(InfiniteRecursionDetected);
 		};
 		Ok(value.clone())
 	}

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -370,17 +370,21 @@
 }
 
 #[macro_export]
-macro_rules! throw {
+macro_rules! bail {
 	($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {
 		return Err($w$(::$i)*$(($($tt)*))?.into())
 	};
 	($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {
 		return Err($w$(::$i)*$({$($tt)*})?.into())
 	};
-	($l:literal) => {
-		return Err($crate::error::ErrorKind::RuntimeError($l.into()).into())
+	($l:literal$(, $($tt:tt)*)?) => {
+		return Err($crate::error::ErrorKind::RuntimeError(format!($l$(, $($tt)*)?).into()).into())
 	};
-	($l:literal, $($tt:tt)*) => {
-		return Err($crate::error::ErrorKind::RuntimeError(format!($l, $($tt)*).into()).into())
+}
+
+#[macro_export]
+macro_rules! runtime_error {
+	($l:literal$(, $($tt:tt)*)?) => {
+		$crate::error::Error::from($crate::error::ErrorKind::RuntimeError(format!($l$(, $($tt)*)?).into()))
 	};
 }

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -3,10 +3,10 @@
 use jrsonnet_parser::{BindSpec, Destruct, LocExpr, ParamsDesc};
 
 use crate::{
+	bail,
 	error::{ErrorKind::*, Result},
 	evaluate, evaluate_method, evaluate_named,
 	gc::GcHashMap,
-	throw,
 	val::ThunkValue,
 	Context, Pending, Thunk, Val,
 };
@@ -23,7 +23,7 @@
 		Destruct::Full(v) => {
 			let old = new_bindings.insert(v.clone(), parent);
 			if old.is_some() {
-				throw!(DuplicateLocalVar(v.clone()))
+				bail!(DuplicateLocalVar(v.clone()))
 			}
 		}
 		#[cfg(feature = "exp-destruct")]
@@ -46,14 +46,14 @@
 				fn get(self: Box<Self>) -> Result<Self::Output> {
 					let v = self.parent.evaluate()?;
 					let Val::Arr(arr) = v else {
-						throw!("expected array");
+						bail!("expected array");
 					};
 					if !self.has_rest {
 						if arr.len() != self.min_len {
-							throw!("expected {} elements, got {}", self.min_len, arr.len())
+							bail!("expected {} elements, got {}", self.min_len, arr.len())
 						}
 					} else if arr.len() < self.min_len {
-						throw!(
+						bail!(
 							"expected at least {} elements, but array was only {}",
 							self.min_len,
 							arr.len()
@@ -178,17 +178,17 @@
 				fn get(self: Box<Self>) -> Result<Self::Output> {
 					let v = self.parent.evaluate()?;
 					let Val::Obj(obj) = v else {
-						throw!("expected object");
+						bail!("expected object");
 					};
 					for field in &self.field_names {
 						if !obj.has_field_ex(field.clone(), true) {
-							throw!("missing field: {}", field);
+							bail!("missing field: {field}");
 						}
 					}
 					if !self.has_rest {
 						let len = obj.len();
 						if len != self.field_names.len() {
-							throw!("too many fields, and rest not found");
+							bail!("too many fields, and rest not found");
 						}
 					}
 					Ok(obj)
@@ -310,7 +310,7 @@
 				}),
 			);
 			if old.is_some() {
-				throw!(DuplicateLocalVar(name.clone()))
+				bail!(DuplicateLocalVar(name.clone()))
 			}
 		}
 	}

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -11,11 +11,11 @@
 use self::destructure::destruct;
 use crate::{
 	arr::ArrValue,
+	bail,
 	destructure::evaluate_dest,
 	error::{suggest_object_fields, ErrorKind::*},
 	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},
 	function::{CallLocation, FuncDesc, FuncVal},
-	throw,
 	typed::Typed,
 	val::{CachedUnbound, IndexableVal, StrValue, Thunk, ThunkValue},
 	Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, ResultExt,
@@ -150,7 +150,7 @@
 					evaluate_comp(ctx, &specs[1..], callback)?;
 				}
 			}
-			_ => throw!(InComprehensionCanOnlyIterateOverArray),
+			_ => bail!(InComprehensionCanOnlyIterateOverArray),
 		},
 	}
 	Ok(())
@@ -375,7 +375,7 @@
 				State::push(loc, || format!("function <{}> call", f.name()), body)?
 			}
 		}
-		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),
+		v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),
 	})
 }
 
@@ -393,9 +393,9 @@
 			|| "assertion failure".to_owned(),
 			|| {
 				if let Some(msg) = msg {
-					throw!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));
+					bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));
 				}
-				throw!(AssertionFailed(Val::Null.to_string()?));
+				bail!(AssertionFailed(Val::Null.to_string()?));
 			},
 		)?;
 	}
@@ -457,12 +457,12 @@
 						if part.null_coaelse {
 							return Ok(Val::Null);
 						}
-						throw!(NoSuperFound)
+						bail!(NoSuperFound)
 					};
 					let name = evaluate(ctx.clone(), &part.value)?;
 
 					let Val::Str(name) = name else {
-						throw!(ValueIndexMustBeTypeGot(
+						bail!(ValueIndexMustBeTypeGot(
 							ValType::Obj,
 							ValType::Str,
 							name.value_type(),
@@ -483,7 +483,7 @@
 						None => {
 							let suggestions = suggest_object_fields(super_obj, name.clone());
 
-							throw!(NoSuchField(name, suggestions))
+							bail!(NoSuchField(name, suggestions))
 						}
 					}
 				}
@@ -502,25 +502,25 @@
 						None => {
 							let suggestions = suggest_object_fields(&v, key.clone().into_flat());
 
-							throw!(NoSuchField(key.clone().into_flat(), suggestions))
+							bail!(NoSuchField(key.clone().into_flat(), suggestions))
 						}
 					},
-					(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
+					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(
 						ValType::Obj,
 						ValType::Str,
 						n.value_type(),
 					)),
 					(Val::Arr(v), Val::Num(n)) => {
 						if n.fract() > f64::EPSILON {
-							throw!(FractionalIndex)
+							bail!(FractionalIndex)
 						}
 						v.get(n as usize)?
 							.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
 					}
 					(Val::Arr(_), Val::Str(n)) => {
-						throw!(AttemptedIndexAnArrayWithString(n.into_flat()))
+						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))
 					}
-					(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
+					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(
 						ValType::Arr,
 						ValType::Num,
 						n.value_type(),
@@ -537,18 +537,18 @@
 							.into();
 						if v.is_empty() {
 							let size = s.into_flat().chars().count();
-							throw!(StringBoundsError(n as usize, size))
+							bail!(StringBoundsError(n as usize, size))
 						}
 						StrValue::Flat(v)
 					}),
-					(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
+					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(
 						ValType::Str,
 						ValType::Num,
 						n.value_type(),
 					)),
 					#[cfg(feature = "exp-null-coaelse")]
 					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),
-					(v, _) => throw!(CantIndexInto(v.value_type())),
+					(v, _) => bail!(CantIndexInto(v.value_type())),
 				};
 			}
 			indexable
@@ -612,7 +612,7 @@
 		ErrorStmt(e) => State::push(
 			CallLocation::new(loc),
 			|| "error statement".to_owned(),
-			|| throw!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
+			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
 		)?,
 		IfElse {
 			cond,
@@ -661,7 +661,7 @@
 		}
 		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {
 			let Expr::Str(path) = &*path.0 else {
-				throw!("computed imports are not supported")
+				bail!("computed imports are not supported")
 			};
 			let tmp = loc.clone().0;
 			let s = ctx.state();

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -4,10 +4,10 @@
 
 use crate::{
 	arr::ArrValue,
+	bail,
 	error::ErrorKind::*,
 	evaluate,
 	stdlib::std_format,
-	throw,
 	typed::Typed,
 	val::{equals, StrValue},
 	Context, Result, Val,
@@ -21,7 +21,7 @@
 		(Minus, Num(n)) => Num(-*n),
 		(Not, Bool(v)) => Bool(!v),
 		(BitNot, Num(n)) => Num(!(*n as i64) as f64),
-		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
+		(op, o) => bail!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
 	})
 }
 
@@ -49,7 +49,7 @@
 		(Num(v1), Num(v2)) => Val::new_checked_num(v1 + v2)?,
 		#[cfg(feature = "exp-bigint")]
 		(BigInt(a), BigInt(b)) => BigInt(Box::new((&**a).clone() + (&**b).clone())),
-		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
+		_ => bail!(BinaryOperatorDoesNotOperateOnValues(
 			BinaryOpType::Add,
 			a.value_type(),
 			b.value_type(),
@@ -62,14 +62,14 @@
 	match (a, b) {
 		(Num(a), Num(b)) => {
 			if *b == 0.0 {
-				throw!(DivisionByZero)
+				bail!(DivisionByZero)
 			}
 			Ok(Num(a % b))
 		}
 		(Str(str), vals) => {
 			String::into_untyped(std_format(&str.clone().into_flat(), vals.clone())?)
 		}
-		(a, b) => throw!(BinaryOperatorDoesNotOperateOnValues(
+		(a, b) => bail!(BinaryOperatorDoesNotOperateOnValues(
 			BinaryOpType::Mod,
 			a.value_type(),
 			b.value_type()
@@ -124,7 +124,7 @@
 			}
 			a.len().cmp(&b.len())
 		}
-		(_, _) => throw!(BinaryOperatorDoesNotOperateOnValues(
+		(_, _) => bail!(BinaryOperatorDoesNotOperateOnValues(
 			op,
 			a.value_type(),
 			b.value_type()
@@ -159,7 +159,7 @@
 		(Num(v1), Mul, Num(v2)) => Val::new_checked_num(v1 * v2)?,
 		(Num(v1), Div, Num(v2)) => {
 			if *v2 == 0.0 {
-				throw!(DivisionByZero)
+				bail!(DivisionByZero)
 			}
 			Val::new_checked_num(v1 / v2)?
 		}
@@ -171,14 +171,14 @@
 		(Num(v1), BitXor, Num(v2)) => Num((*v1 as i64 ^ *v2 as i64) as f64),
 		(Num(v1), Lhs, Num(v2)) => {
 			if *v2 < 0.0 {
-				throw!("shift by negative exponent")
+				bail!("shift by negative exponent")
 			}
 			let exp = ((*v2 as i64) & 63) as u32;
 			Num((*v1 as i64).wrapping_shl(exp) as f64)
 		}
 		(Num(v1), Rhs, Num(v2)) => {
 			if *v2 < 0.0 {
-				throw!("shift by negative exponent")
+				bail!("shift by negative exponent")
 			}
 			let exp = ((*v2 as i64) & 63) as u32;
 			Num((*v1 as i64).wrapping_shr(exp) as f64)
@@ -190,7 +190,7 @@
 		#[cfg(feature = "exp-bigint")]
 		(BigInt(a), Sub, BigInt(b)) => BigInt(Box::new((&**a).clone() - (&**b).clone())),
 
-		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
+		_ => bail!(BinaryOperatorDoesNotOperateOnValues(
 			op,
 			a.value_type(),
 			b.value_type(),

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -3,14 +3,7 @@
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, LocExpr};
 
-use crate::{
-	error::Result,
-	evaluate,
-	gc::GcHashMap,
-	typed::Typed,
-	val::{StrValue, ThunkValue},
-	Context, Thunk, Val,
-};
+use crate::{evaluate, gc::GcHashMap, typed::Typed, val::ThunkValue, Context, Result, Thunk, Val};
 
 /// Marker for arguments, which can be evaluated with context set to None
 pub trait OptionalContext {}

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -4,7 +4,7 @@
 use jrsonnet_interner::IStr;
 
 use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
-use crate::{error::Result, gc::TraceBox, tb, Context, Val};
+use crate::{gc::TraceBox, tb, Context, Result, Val};
 
 /// Can't have str | IStr, because constant BuiltinParam causes
 /// E0492: constant functions cannot refer to interior mutable data

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -6,11 +6,11 @@
 
 use super::{arglike::ArgsLike, builtin::BuiltinParam};
 use crate::{
+	bail,
 	destructure::destruct,
 	error::{ErrorKind::*, Result},
 	evaluate_named,
 	gc::GcHashMap,
-	throw,
 	val::ThunkValue,
 	Context, Pending, Thunk, Val,
 };
@@ -47,7 +47,7 @@
 	let mut passed_args =
 		GcHashMap::with_capacity(params.iter().map(|p| p.0.capacity_hint()).sum());
 	if args.unnamed_len() > params.len() {
-		throw!(TooManyArgsFunctionHas(
+		bail!(TooManyArgsFunctionHas(
 			params.len(),
 			params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()
 		))
@@ -71,10 +71,10 @@
 	args.named_iter(ctx, tailstrict, &mut |name, value| {
 		// FIXME: O(n) for arg existence check
 		if !params.iter().any(|p| p.0.name().as_ref() == Some(name)) {
-			throw!(UnknownFunctionParameter((name as &str).to_owned()));
+			bail!(UnknownFunctionParameter((name as &str).to_owned()));
 		}
 		if passed_args.insert(name.clone(), value).is_some() {
-			throw!(BindingParameterASecondTime(name.clone()));
+			bail!(BindingParameterASecondTime(name.clone()));
 		}
 		filled_named += 1;
 		Ok(())
@@ -125,7 +125,7 @@
 					}
 				});
 				if !found {
-					throw!(FunctionParameterNotBoundInCall(
+					bail!(FunctionParameterNotBoundInCall(
 						param.0.clone().name(),
 						params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()
 					));
@@ -159,7 +159,7 @@
 ) -> Result<Vec<Option<Thunk<Val>>>> {
 	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];
 	if args.unnamed_len() > params.len() {
-		throw!(TooManyArgsFunctionHas(
+		bail!(TooManyArgsFunctionHas(
 			params.len(),
 			params
 				.iter()
@@ -183,7 +183,7 @@
 			.position(|p| p.name() == name)
 			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
 		if replace(&mut passed_args[id], Some(arg)).is_some() {
-			throw!(BindingParameterASecondTime(name.clone()));
+			bail!(BindingParameterASecondTime(name.clone()));
 		}
 		filled_args += 1;
 		Ok(())
@@ -207,7 +207,7 @@
 					}
 				});
 				if !found {
-					throw!(FunctionParameterNotBoundInCall(
+					bail!(FunctionParameterNotBoundInCall(
 						param.name().as_str().map(IStr::from),
 						params
 							.iter()

--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -12,8 +12,8 @@
 use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
 
 use crate::{
+	bail,
 	error::{ErrorKind::*, Result},
-	throw,
 };
 
 /// Implements file resolution logic for `import` and `importStr`
@@ -25,14 +25,14 @@
 	/// `from` should only be returned from [`ImportResolver::resolve`], or from other defined file, any other value
 	/// may result in panic
 	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
-		throw!(ImportNotSupported(from.clone(), path.into()))
+		bail!(ImportNotSupported(from.clone(), path.into()))
 	}
 	fn resolve_from_default(&self, path: &str) -> Result<SourcePath> {
 		self.resolve_from(&SourcePath::default(), path)
 	}
 	/// Resolves absolute path, doesn't supports jpath and other fancy things
 	fn resolve(&self, path: &Path) -> Result<SourcePath> {
-		throw!(AbsoluteImportNotSupported(path.to_owned()))
+		bail!(AbsoluteImportNotSupported(path.to_owned()))
 	}
 
 	/// Load resolved file
@@ -110,16 +110,16 @@
 					)));
 				}
 			}
-			throw!(ImportFileNotFound(from.clone(), path.to_owned()))
+			bail!(ImportFileNotFound(from.clone(), path.to_owned()))
 		}
 	}
 	fn resolve(&self, path: &Path) -> Result<SourcePath> {
 		let meta = match fs::metadata(path) {
 			Ok(v) => v,
 			Err(e) if e.kind() == ErrorKind::NotFound => {
-				throw!(AbsoluteImportFileNotFound(path.to_owned()))
+				bail!(AbsoluteImportFileNotFound(path.to_owned()))
 			}
-			Err(e) => throw!(ImportIo(e.to_string())),
+			Err(e) => bail!(ImportIo(e.to_string())),
 		};
 		if meta.is_file() {
 			Ok(SourcePath::new(SourceFile::new(
@@ -138,7 +138,7 @@
 		let path = if let Some(f) = id.downcast_ref::<SourceFile>() {
 			f.path()
 		} else if id.downcast_ref::<SourceDirectory>().is_some() || id.is_default() {
-			throw!(ImportIsADirectory(id.clone()))
+			bail!(ImportIsADirectory(id.clone()))
 		} else {
 			unreachable!("other types are not supported in resolve");
 		};

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -620,6 +620,6 @@
 	where
 		T: std::fmt::Display,
 	{
-		JrError::new(ErrorKind::RuntimeError(format!("serde: {msg}").into()))
+		runtime_error!("serde: {msg}")
 	}
 }

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -354,7 +354,7 @@
 		}
 		let parsed = file.parsed.as_ref().expect("just set").clone();
 		if file.evaluating {
-			throw!(InfiniteRecursionDetected)
+			bail!(InfiniteRecursionDetected)
 		}
 		file.evaluating = true;
 		// Dropping file cache guard here, as evaluation may use this map too

--- a/crates/jrsonnet-evaluator/src/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/manifest.rs
@@ -1,9 +1,6 @@
 use std::{borrow::Cow, fmt::Write};
 
-use crate::{
-	error::{ErrorKind::*, Result},
-	throw, State, Val,
-};
+use crate::{bail, Result, State, Val};
 
 pub trait ManifestFormat {
 	fn manifest_buf(&self, val: Val, buf: &mut String) -> Result<()>;
@@ -268,7 +265,7 @@
 			}
 			buf.push('}');
 		}
-		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
+		Val::Func(_) => bail!("tried to manifest function"),
 	};
 	Ok(())
 }
@@ -292,7 +289,7 @@
 impl ManifestFormat for StringFormat {
 	fn manifest_buf(&self, val: Val, out: &mut String) -> Result<()> {
 		let Val::Str(s) = val else {
-			throw!(
+			bail!(
 				"output should be string for string manifest format, got {}",
 				val.value_type()
 			)
@@ -309,7 +306,7 @@
 impl<I: ManifestFormat> ManifestFormat for YamlStreamFormat<I> {
 	fn manifest_buf(&self, val: Val, out: &mut String) -> Result<()> {
 		let Val::Arr(arr) = val else {
-			throw!(
+			bail!(
 				"output should be array for yaml stream format, got {}",
 				val.value_type()
 			)

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -13,11 +13,12 @@
 
 use crate::{
 	arr::{PickObjectKeyValues, PickObjectValues},
+	bail,
 	error::{suggest_object_fields, Error, ErrorKind::*},
 	function::CallLocation,
 	gc::{GcHashMap, GcHashSet, TraceBox},
 	operator::evaluate_add_op,
-	tb, throw,
+	tb,
 	val::{ArrValue, ThunkValue},
 	MaybeUnbound, Result, State, Thunk, Unbound, Val,
 };
@@ -404,7 +405,7 @@
 	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {
 		let Some(value) = self.get(key.clone())? else {
 			let suggestions = suggest_object_fields(self, key.clone());
-			throw!(NoSuchField(key, suggestions))
+			bail!(NoSuchField(key, suggestions))
 		};
 		Ok(value)
 	}
@@ -723,7 +724,7 @@
 			return Ok(match v {
 				CacheValue::Cached(v) => Some(v.clone()),
 				CacheValue::NotFound => None,
-				CacheValue::Pending => throw!(InfiniteRecursionDetected),
+				CacheValue::Pending => bail!(InfiniteRecursionDetected),
 				CacheValue::Errored(e) => return Err(e.clone()),
 			});
 		}
@@ -953,7 +954,7 @@
 			State::push(
 				CallLocation(location.as_ref()),
 				|| format!("field <{}> initializtion", name.clone()),
-				|| throw!(DuplicateFieldName(name.clone())),
+				|| bail!(DuplicateFieldName(name.clone())),
 			)?;
 		}
 		Ok(())