git.delta.rocks / jrsonnet / refs/commits / 5e6d5ee048e2

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -32,7 +32,7 @@
 		Destruct::Array { start, rest, end } => {
 			use jrsonnet_parser::DestructRest;
 
-			use crate::{throw_runtime, val::ArrValue};
+			use crate::{throw, val::ArrValue};
 
 			#[derive(Trace)]
 			struct DataThunk {
@@ -47,14 +47,14 @@
 					let v = self.parent.evaluate(s)?;
 					let arr = match v {
 						Val::Arr(a) => a,
-						_ => throw_runtime!("expected array"),
+						_ => throw!("expected array"),
 					};
 					if !self.has_rest {
 						if arr.len() != self.min_len {
-							throw_runtime!("expected {} elements, got {}", self.min_len, arr.len())
+							throw!("expected {} elements, got {}", self.min_len, arr.len())
 						}
 					} else if arr.len() < self.min_len {
-						throw_runtime!(
+						throw!(
 							"expected at least {} elements, but array was only {}",
 							self.min_len,
 							arr.len()
@@ -163,7 +163,7 @@
 		}
 		#[cfg(feature = "exp-destruct")]
 		Destruct::Object { fields, rest } => {
-			use crate::{obj::ObjValue, throw_runtime};
+			use crate::{obj::ObjValue, throw};
 
 			#[derive(Trace)]
 			struct DataThunk {
@@ -178,17 +178,17 @@
 					let v = self.parent.evaluate(s)?;
 					let obj = match v {
 						Val::Obj(o) => o,
-						_ => throw_runtime!("expected object"),
+						_ => throw!("expected object"),
 					};
 					for field in &self.field_names {
 						if !obj.has_field_ex(field.clone(), true) {
-							throw_runtime!("missing field: {}", field);
+							throw!("missing field: {}", field);
 						}
 					}
 					if !self.has_rest {
 						let len = obj.len();
 						if len != self.field_names.len() {
-							throw_runtime!("too many fields, and rest not found");
+							throw!("too many fields, and rest not found");
 						}
 					}
 					Ok(obj)

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -150,13 +150,13 @@
 		(Num(v1), BitXor, Num(v2)) => Num(f64::from((*v1 as i32) ^ (*v2 as i32))),
 		(Num(v1), Lhs, Num(v2)) => {
 			if *v2 < 0.0 {
-				throw!(RuntimeError("shift by negative exponent".into()))
+				throw!("shift by negative exponent")
 			}
 			Num(f64::from((*v1 as i32) << (*v2 as i32)))
 		}
 		(Num(v1), Rhs, Num(v2)) => {
 			if *v2 < 0.0 {
-				throw!(RuntimeError("shift by negative exponent".into()))
+				throw!("shift by negative exponent")
 			}
 			Num(f64::from((*v1 as i32) >> (*v2 as i32)))
 		}

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -72,7 +72,7 @@
 				}
 				Self::Object(out)
 			}
-			Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
+			Val::Func(_) => throw!("tried to manifest function"),
 		})
 	}
 }

--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -591,9 +591,7 @@
 			),
 			Val::Str(s) => {
 				if s.chars().count() != 1 {
-					throw!(RuntimeError(
-						format!("%c expected 1 char string, got {}", s.chars().count()).into(),
-					));
+					throw!("%c expected 1 char string, got {}", s.chars().count(),);
 				}
 				tmp_out.push_str(&s);
 			}

--- a/crates/jrsonnet-evaluator/src/stdlib/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/manifest.rs
@@ -341,7 +341,7 @@
 				}
 			}
 		}
-		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
+		Val::Func(_) => throw!("tried to manifest function"),
 	}
 	Ok(())
 }

--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -6,7 +6,7 @@
 use jrsonnet_types::{ComplexValType, ValType};
 
 use crate::{
-	error::{Error::*, Result},
+	error::Result,
 	function::{FuncDesc, FuncVal},
 	throw,
 	typed::CheckType,
@@ -41,13 +41,10 @@
 					Val::Num(n) => {
 						#[allow(clippy::float_cmp)]
 						if n.trunc() != n {
-							throw!(RuntimeError(
-								format!(
-									"cannot convert number with fractional part to {}",
-									stringify!($ty)
-								)
-								.into()
-							))
+							throw!(
+								"cannot convert number with fractional part to {}",
+								stringify!($ty)
+							)
 						}
 						Ok(n as Self)
 					}
@@ -99,13 +96,10 @@
 					Val::Num(n) => {
 						#[allow(clippy::float_cmp)]
 						if n.trunc() != n {
-							throw!(RuntimeError(
-								format!(
-									"cannot convert number with fractional part to {}",
-									stringify!($ty)
-								)
-								.into()
-							))
+							throw!(
+								"cannot convert number with fractional part to {}",
+								stringify!($ty)
+							)
 						}
 						Ok(Self(n as $ty))
 					}
@@ -167,7 +161,7 @@
 
 	fn into_untyped(value: Self, _: State) -> Result<Val> {
 		if value > u32::MAX as Self {
-			throw!(RuntimeError("number is too large".into()))
+			throw!("number is too large")
 		}
 		Ok(Val::Num(value as f64))
 	}
@@ -178,9 +172,7 @@
 			Val::Num(n) => {
 				#[allow(clippy::float_cmp)]
 				if n.trunc() != n {
-					throw!(RuntimeError(
-						"cannot convert number with fractional part to usize".into()
-					))
+					throw!("cannot convert number with fractional part to usize")
 				}
 				Ok(n as Self)
 			}
@@ -440,7 +432,7 @@
 		<Self as Typed>::TYPE.check(s, &value)?;
 		match value {
 			Val::Func(FuncVal::Normal(desc)) => Ok(desc),
-			Val::Func(_) => throw!(RuntimeError("expected normal function, not builtin".into())),
+			Val::Func(_) => throw!("expected normal function, not builtin"),
 			_ => unreachable!(),
 		}
 	}

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -629,7 +629,7 @@
 		if num.is_finite() {
 			Ok(Self::Num(num))
 		} else {
-			throw!(RuntimeError("overflow".into()))
+			throw!("overflow")
 		}
 	}
 
@@ -843,14 +843,14 @@
 		(Val::Null, Val::Null) => true,
 		(Val::Str(a), Val::Str(b)) => a == b,
 		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,
-		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(
-			"primitiveEquals operates on primitive types, got array".into(),
-		)),
-		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(
-			"primitiveEquals operates on primitive types, got object".into(),
-		)),
+		(Val::Arr(_), Val::Arr(_)) => {
+			throw!("primitiveEquals operates on primitive types, got array")
+		}
+		(Val::Obj(_), Val::Obj(_)) => {
+			throw!("primitiveEquals operates on primitive types, got object")
+		}
 		(a, b) if is_function_like(a) && is_function_like(b) => {
-			throw!(RuntimeError("cannot test equality of functions".into()))
+			throw!("cannot test equality of functions")
 		}
 		(_, _) => false,
 	})

--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -1,7 +1,7 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	function::{builtin, FuncVal},
-	throw_runtime,
+	throw,
 	typed::{Any, BoundedUsize, Typed, VecVal},
 	val::{equals, ArrValue, IndexableVal},
 	IStr, State, Val,
@@ -43,7 +43,7 @@
 				match func.evaluate_simple(s.clone(), &(c.to_string(),))? {
 					Val::Str(o) => out.push_str(&o),
 					Val::Null => continue,
-					_ => throw_runtime!("in std.join all items should be strings"),
+					_ => throw!("in std.join all items should be strings"),
 				};
 			}
 			Ok(IndexableVal::Str(out.into()))
@@ -59,7 +59,7 @@
 						}
 					}
 					Val::Null => continue,
-					_ => throw_runtime!("in std.join all items should be arrays"),
+					_ => throw!("in std.join all items should be arrays"),
 				};
 			}
 			Ok(IndexableVal::Arr(out.into()))
@@ -128,7 +128,7 @@
 				} else if matches!(item, Val::Null) {
 					continue;
 				} else {
-					throw_runtime!("in std.join all items should be arrays");
+					throw!("in std.join all items should be arrays");
 				}
 			}
 
@@ -149,7 +149,7 @@
 				} else if matches!(item, Val::Null) {
 					continue;
 				} else {
-					throw_runtime!("in std.join all items should be strings");
+					throw!("in std.join all items should be strings");
 				}
 			}
 

--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -8,7 +8,7 @@
 	error::{Error::*, Result},
 	function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},
 	gc::{GcHashMap, TraceBox},
-	tb, throw_runtime,
+	tb, throw,
 	trace::PathResolver,
 	typed::{Any, Either, Either2, Either4, VecVal, M1},
 	val::{equals, ArrValue},
@@ -500,7 +500,7 @@
 				true
 			}
 		}
-		_ => throw_runtime!("both arguments should be of the same type"),
+		_ => throw!("both arguments should be of the same type"),
 	})
 }
 
@@ -534,7 +534,7 @@
 				true
 			}
 		}
-		_ => throw_runtime!("both arguments should be of the same type"),
+		_ => throw!("both arguments should be of the same type"),
 	})
 }
 

--- a/crates/jrsonnet-stdlib/src/sort.rs
+++ b/crates/jrsonnet-stdlib/src/sort.rs
@@ -1,7 +1,7 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	function::{builtin, FuncVal},
-	throw_runtime,
+	throw,
 	typed::Any,
 	val::ArrValue,
 	State, Val,
@@ -41,9 +41,9 @@
 			(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,
 			(Val::Str(_), SortKeyType::String) | (Val::Num(_), SortKeyType::Number) => {}
 			(Val::Str(_) | Val::Num(_), _) => {
-				throw_runtime!("sort elements should have the same types")
+				throw!("sort elements should have the same types")
 			}
-			_ => throw_runtime!("sort key should either be a string or a number"),
+			_ => throw!("sort key should either be a string or a number"),
 		}
 	}
 	Ok(sort_type)

--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -1,7 +1,7 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	function::{builtin, FuncVal},
-	throw_runtime, ObjValueBuilder, State, Thunk, Val,
+	throw, ObjValueBuilder, State, Thunk, Val,
 };
 use jrsonnet_stdlib::StateExt;
 
@@ -11,7 +11,7 @@
 		let a = &$a;
 		let b = &$b;
 		if a != b {
-			::jrsonnet_evaluator::throw_runtime!("assertion failed: a != b\na={:#?}\nb={:#?}", a, b)
+			::jrsonnet_evaluator::throw!("assertion failed: a != b\na={:#?}\nb={:#?}", a, b)
 		}
 	}};
 }
@@ -20,7 +20,7 @@
 macro_rules! ensure {
 	($v:expr $(,)?) => {
 		if !$v {
-			::jrsonnet_evaluator::throw_runtime!("assertion failed: {}", stringify!($v))
+			::jrsonnet_evaluator::throw!("assertion failed: {}", stringify!($v))
 		}
 	};
 }
@@ -29,7 +29,7 @@
 macro_rules! ensure_val_eq {
 	($s:expr, $a:expr, $b:expr) => {{
 		if !::jrsonnet_evaluator::val::equals($s.clone(), &$a.clone(), &$b.clone())? {
-			::jrsonnet_evaluator::throw_runtime!(
+			::jrsonnet_evaluator::throw!(
 				"assertion failed: a != b\na={:#?}\nb={:#?}",
 				$a.to_json(
 					$s.clone(),
@@ -52,7 +52,7 @@
 fn assert_throw(s: State, lazy: Thunk<Val>, message: String) -> Result<bool> {
 	match lazy.evaluate(s) {
 		Ok(_) => {
-			throw_runtime!("expected argument to throw on evaluation, but it returned instead")
+			throw!("expected argument to throw on evaluation, but it returned instead")
 		}
 		Err(e) => {
 			let error = format!("{}", e.error());

--- a/tests/tests/sanity.rs
+++ b/tests/tests/sanity.rs
@@ -1,4 +1,4 @@
-use jrsonnet_evaluator::{error::Result, throw_runtime, State, Val};
+use jrsonnet_evaluator::{error::Result, throw, State, Val};
 use jrsonnet_stdlib::StateExt;
 
 mod common;
@@ -23,7 +23,7 @@
 
 	{
 		let e = match s.evaluate_snippet("snip".to_owned(), "assert 1 == 2: 'fail'; null") {
-			Ok(_) => throw_runtime!("assertion should fail"),
+			Ok(_) => throw!("assertion should fail"),
 			Err(e) => e,
 		};
 		let e = s.stringify_err(&e);
@@ -31,7 +31,7 @@
 	}
 	{
 		let e = match s.evaluate_snippet("snip".to_owned(), "std.assertEqual(1, 2)") {
-			Ok(_) => throw_runtime!("assertion should fail"),
+			Ok(_) => throw!("assertion should fail"),
 			Err(e) => e,
 		};
 		let e = s.stringify_err(&e);