git.delta.rocks / jrsonnet / refs/commits / 84f648e78329

difftreelog

refact: simplify error management

Лач2020-07-21parent: #370c615.patch.diff
in: master

18 files changed

modifiedbindings/jsonnet/src/import.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -1,7 +1,8 @@
 //! Import resolution manipulation utilities
 
 use jrsonnet_evaluator::{
-	create_error, create_error_result, Error, EvaluationState, ImportResolver, Result,
+	error::{Error::*, Result},
+	throw, EvaluationState, ImportResolver,
 };
 use std::{
 	any::Any,
@@ -55,10 +56,9 @@
 		let result_str = result_raw.to_str().unwrap();
 		assert!(success == 0 || success == 1);
 		if success == 0 {
+			unsafe { CString::from_raw(result_ptr) };
 			let result = result_str.to_owned();
-			let err = Err(create_error(Error::ImportCallbackError(result)));
-			unsafe { CString::from_raw(result_ptr) };
-			return err;
+			throw!(ImportCallbackError(result));
 		}
 
 		let found_here_raw = unsafe { CStr::from_ptr(found_here) };
@@ -121,15 +121,14 @@
 					return Ok(Rc::new(cloned));
 				}
 			}
-			create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))
+			throw!(ImportFileNotFound(from.clone(), path.clone()))
 		}
 	}
 	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
-		let mut file =
-			File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;
+		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
 		let mut out = String::new();
 		file.read_to_string(&mut out)
-			.map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;
+			.map_err(|_e| ImportBadFileUtf8(id.clone()))?;
 		Ok(out.into())
 	}
 	unsafe fn as_any(&self) -> &dyn Any {
modifiedcmds/jrsonnet/src/main.rsdiffbeforeafterboth
--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -1,6 +1,6 @@
 use clap::Clap;
 use jrsonnet_cli::{ConfigureState, GeneralOpts, InputOpts, ManifestOpts};
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
 use std::{path::PathBuf, rc::Rc};
 
 #[global_allocator]
modifiedcrates/jrsonnet-cli/src/ext.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/ext.rs
+++ b/crates/jrsonnet-cli/src/ext.rs
@@ -1,6 +1,6 @@
 use crate::ConfigureState;
 use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
 use std::str::FromStr;
 
 #[derive(Clone)]
modifiedcrates/jrsonnet-cli/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -9,7 +9,7 @@
 pub use trace::*;
 
 use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, FileImportResolver, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState, FileImportResolver};
 use std::path::PathBuf;
 
 pub trait ConfigureState {
modifiedcrates/jrsonnet-cli/src/manifest.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -1,6 +1,6 @@
 use crate::ConfigureState;
 use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState, ManifestFormat};
 use std::str::FromStr;
 
 pub enum ManifestFormatName {
modifiedcrates/jrsonnet-cli/src/tla.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,6 +1,6 @@
 use crate::{ConfigureState, ExtStr};
 use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
 
 #[derive(Clap)]
 // #[clap(help_heading = "TOP LEVEL ARGUMENTS")]
modifiedcrates/jrsonnet-cli/src/trace.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/trace.rs
+++ b/crates/jrsonnet-cli/src/trace.rs
@@ -1,8 +1,9 @@
 use crate::ConfigureState;
 use clap::Clap;
 use jrsonnet_evaluator::{
+	error::Result,
 	trace::{CompactFormat, ExplainingFormat, PathResolver},
-	EvaluationState, Result,
+	EvaluationState,
 };
 use std::str::FromStr;
modifiedcrates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -1,31 +1,32 @@
 //! faster std.format impl
 #![allow(clippy::too_many_arguments)]
 
-use crate::{
-	create_error, create_error_result, to_string, Error, LocError, ObjValue, Val, ValType,
-};
+use crate::{error::Error::*, throw, to_string, LocError, ObjValue, Result, Val, ValType};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum FormatError {
 	TruncatedFormatCode,
 	UnrecognizedConversionType(char),
-	ValueError(LocError),
 
 	NotEnoughValues,
 
 	CannotUseStarWidthWithObject,
 	MappingKeysRequired,
-	NoSuchField(Rc<str>),
+	NoSuchFormatField(Rc<str>),
 }
-impl From<LocError> for FormatError {
-	fn from(e: LocError) -> Self {
-		Self::ValueError(e)
+
+impl From<FormatError> for LocError {
+	fn from(e: FormatError) -> Self {
+		Self::new(Format(e))
 	}
 }
+
 use std::rc::Rc;
 use FormatError::*;
 
-pub fn try_parse_mapping_key(str: &str) -> Result<(&str, &str), FormatError> {
+type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;
+
+pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -84,7 +85,7 @@
 	pub sign: bool,
 }
 
-pub fn try_parse_cflags(str: &str) -> Result<(CFlags, &str), FormatError> {
+pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -113,7 +114,7 @@
 	Star,
 	Fixed(usize),
 }
-pub fn try_parse_field_width(str: &str) -> Result<(Width, &str), FormatError> {
+pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -134,7 +135,7 @@
 	Ok((Width::Fixed(out), &str[digits..]))
 }
 
-pub fn try_parse_precision(str: &str) -> Result<(Option<Width>, &str), FormatError> {
+pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -147,7 +148,7 @@
 }
 
 // Only skips
-pub fn try_parse_length_modifier(str: &str) -> Result<&str, FormatError> {
+pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -159,10 +160,10 @@
 			return Err(TruncatedFormatCode);
 		}
 	}
-	Ok(&str[idx..])
+	Ok(((), &str[idx..]))
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum ConvTypeV {
 	Decimal,
 	Octal,
@@ -179,7 +180,7 @@
 	caps: bool,
 }
 
-pub fn parse_conversion_type(str: &str) -> Result<(ConvType, &str), FormatError> {
+pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -214,7 +215,7 @@
 	convtype: ConvTypeV,
 	caps: bool,
 }
-pub fn parse_code(str: &str) -> Result<(Code, &str), FormatError> {
+pub fn parse_code(str: &str) -> ParseResult<Code> {
 	if str.is_empty() {
 		return Err(TruncatedFormatCode);
 	}
@@ -222,7 +223,7 @@
 	let (cflags, str) = try_parse_cflags(str)?;
 	let (width, str) = try_parse_field_width(str)?;
 	let (precision, str) = try_parse_precision(str)?;
-	let str = try_parse_length_modifier(str)?;
+	let (_, str) = try_parse_length_modifier(str)?;
 	let (convtype, str) = parse_conversion_type(str)?;
 
 	Ok((
@@ -243,7 +244,7 @@
 	String(&'s str),
 	Code(Code<'s>),
 }
-pub fn parse_codes(mut str: &str) -> Result<Vec<Element>, FormatError> {
+pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {
 	let mut bytes = str.as_bytes();
 	let mut out = vec![];
 	let mut offset = 0;
@@ -453,7 +454,7 @@
 	code: &Code,
 	width: usize,
 	precision: Option<usize>,
-) -> Result<(), FormatError> {
+) -> Result<()> {
 	let clfags = &code.cflags;
 	let (fpprec, iprec) = match precision {
 		Some(v) => (v, v),
@@ -565,22 +566,22 @@
 		ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {
 			Val::Num(n) => tmp_out.push(
 				std::char::from_u32(n as u32)
-					.ok_or_else(|| create_error(Error::InvalidUnicodeCodepointGot(n as u32)))?,
+					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,
 			),
 			Val::Str(s) => {
 				if s.chars().count() != 1 {
-					create_error_result(Error::RuntimeError(
+					throw!(RuntimeError(
 						format!("%c expected 1 char string, got {}", s.chars().count()).into(),
-					))?;
+					));
 				}
 				tmp_out.push_str(&s);
 			}
 			_ => {
-				create_error_result(Error::TypeMismatch(
+				throw!(TypeMismatch(
 					"%c requires number/string",
 					vec![ValType::Num, ValType::Str],
 					value.value_type()?,
-				))?;
+				));
 			}
 		},
 		ConvTypeV::Percent => tmp_out.push('%'),
@@ -603,7 +604,7 @@
 	Ok(())
 }
 
-pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String, FormatError> {
+pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {
 	let codes = parse_codes(&str)?;
 	let mut out = String::new();
 
@@ -616,7 +617,7 @@
 				let width = match c.width {
 					Width::Star => {
 						if values.is_empty() {
-							return Err(FormatError::NotEnoughValues);
+							throw!(NotEnoughValues);
 						}
 						let value = &values[0];
 						values = &values[1..];
@@ -627,7 +628,7 @@
 				let precision = match c.precision {
 					Some(Width::Star) => {
 						if values.is_empty() {
-							return Err(FormatError::NotEnoughValues);
+							throw!(NotEnoughValues);
 						}
 						let value = &values[0];
 						values = &values[1..];
@@ -642,7 +643,7 @@
 					&Val::Null
 				} else {
 					if values.is_empty() {
-						return Err(FormatError::NotEnoughValues);
+						throw!(NotEnoughValues);
 					}
 					let value = &values[0];
 					values = &values[1..];
@@ -657,7 +658,7 @@
 	Ok(out)
 }
 
-pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {
+pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {
 	let codes = parse_codes(&str)?;
 	let mut out = String::new();
 
@@ -670,17 +671,17 @@
 				// TODO: Operate on ref
 				let f: Rc<str> = c.mkey.into();
 				if f.is_empty() {
-					return Err(FormatError::MappingKeysRequired);
+					throw!(MappingKeysRequired);
 				}
 				let width = match c.width {
 					Width::Star => {
-						return Err(FormatError::CannotUseStarWidthWithObject);
+						throw!(CannotUseStarWidthWithObject);
 					}
 					Width::Fixed(n) => n,
 				};
 				let precision = match c.precision {
 					Some(Width::Star) => {
-						return Err(FormatError::CannotUseStarWidthWithObject);
+						throw!(CannotUseStarWidthWithObject);
 					}
 					Some(Width::Fixed(n)) => Some(n),
 					None => None,
@@ -688,7 +689,7 @@
 				let value = if let Some(v) = values.get(f.clone())? {
 					v
 				} else {
-					return Err(FormatError::NoSuchField(f));
+					throw!(NoSuchFormatField(f));
 				};
 
 				format_code(&mut out, &value, &c, width, precision)?;
modifiedcrates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -1,5 +1,5 @@
 use crate::{
-	create_error, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val, Error,
+	error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,
 	LazyBinding, LazyVal, ObjValue, Result, Val,
 };
 use std::{
@@ -61,11 +61,12 @@
 	}
 
 	pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {
-		self.0
+		Ok(self
+			.0
 			.bindings
 			.get(&name)
 			.cloned()
-			.ok_or_else(|| create_error(Error::UnknownVariable(name)))
+			.ok_or_else(|| UnknownVariable(name))?)
 	}
 	pub fn into_future(self, ctx: FutureContext) -> Context {
 		{
modifiedcrates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -1,4 +1,4 @@
-use crate::{Val, ValType};
+use crate::{builtin::format::FormatError, Val, ValType};
 use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
 use std::{path::PathBuf, rc::Rc};
 
@@ -61,7 +61,14 @@
 
 	ImportCallbackError(String),
 	InvalidUnicodeCodepointGot(u32),
+
+	Format(FormatError),
 }
+impl From<Error> for LocError {
+	fn from(e: Error) -> Self {
+		Self(e, StackTrace(vec![]))
+	}
+}
 
 #[derive(Clone, Debug)]
 pub struct StackTraceElement {
@@ -73,4 +80,17 @@
 
 #[derive(Debug, Clone)]
 pub struct LocError(pub Error, pub StackTrace);
+impl LocError {
+	pub fn new(e: Error) -> Self {
+		Self(e, StackTrace(vec![]))
+	}
+}
+
 pub type Result<V> = std::result::Result<V, LocError>;
+
+#[macro_export]
+macro_rules! throw {
+	($e: expr) => {
+		return Err($e.into());
+	};
+}
modifiedcrates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth
1use crate::{1use crate::{
2	builtin::format::{format_arr, format_obj},2	builtin::format::{format_arr, format_obj},
3	context_creator, create_error, create_error_result, equals, escape_string_json, future_wrapper,3	context_creator, equals,
4	error::Error::*,
4	lazy_val, manifest_json_ex, parse_args, primitive_equals, push, with_state, Context,5	escape_string_json, future_wrapper, lazy_val, manifest_json_ex, parse_args, primitive_equals,
5	ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,6	push, throw, with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError,
6	ValType,7	ObjMember, ObjValue, Result, Val, ValType,
7};8};
8use closure::closure;9use closure::closure;
9use jrsonnet_parser::{10use jrsonnet_parser::{
10	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,11	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,
11	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,12	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
12	Visibility,13	Visibility,
13};14};
14use std::{cmp::Ordering, collections::HashMap, rc::Rc};15use std::{cmp::Ordering, collections::HashMap, path::PathBuf, rc::Rc};
1516
16pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {17pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {
17	let b = b.clone();18	let b = b.clone();
79		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),80		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),
80		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),81		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),
81		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),82		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),
82		(op, o) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(83		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),
83			op,
84			o.value_type()?,
85		))?,
86	})84	})
87}85}
8886
100		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),98		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
101		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),99		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
102		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,100		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,
103		_ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(101		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
104			BinaryOpType::Add,102			BinaryOpType::Add,
105			a.value_type()?,103			a.value_type()?,
106			b.value_type()?,104			b.value_type()?,
107		))?,105		)),
108	})106	})
109}107}
110108
145		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,143		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,
146		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {144		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {
147			if *v2 <= f64::EPSILON {145			if *v2 <= f64::EPSILON {
148				create_error_result(crate::Error::DivisionByZero)?146				throw!(DivisionByZero)
149			}147			}
150			Val::new_checked_num(v1 / v2)?148			Val::new_checked_num(v1 / v2)?
151		}149		}
168		}166		}
169		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {167		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {
170			if *v2 < 0.0 {168			if *v2 < 0.0 {
171				create_error_result(Error::RuntimeError("shift by negative exponent".into()))?169				throw!(RuntimeError("shift by negative exponent".into()))
172			}170			}
173			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)171			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)
174		}172		}
175		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {173		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {
176			if *v2 < 0.0 {174			if *v2 < 0.0 {
177				create_error_result(Error::RuntimeError("shift by negative exponent".into()))?175				throw!(RuntimeError("shift by negative exponent".into()))
178			}176			}
179			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)177			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)
180		}178		}
181179
182		_ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(180		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
183			op,181			op,
184			a.value_type()?,182			a.value_type()?,
185			b.value_type()?,183			b.value_type()?,
186		))?,184		)),
187	})185	})
188}186}
189187
218					}216					}
219					Some(out.into_iter().flatten().flatten().collect())217					Some(out.into_iter().flatten().flatten().collect())
220				}218				}
221				_ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,219				_ => throw!(InComprehensionCanOnlyIterateOverArray),
222			}220			}
223		}221		}
224	})222	})
379							},377							},
380						);378						);
381					}379					}
382					v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,380					v => throw!(FieldMustBeStringGot(v.value_type()?)),
383				}381				}
384			}382			}
385383
409	Ok(match value {407	Ok(match value {
410		Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {408		Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {
411			// arr/string/function409			// arr/string/function
412			("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [410			("std", "length") => parse_args!(context, "std.length", args, 1, [
413				0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];411				0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];
414			], {412			], {
415				Ok(match x {413				Ok(match x {
423					),421					),
424					_ => unreachable!(),422					_ => unreachable!(),
425				})423				})
426			}))?,424			})?,
427			// any425			// any
428			("std", "type") => parse_args!(context, "std.type", args, 1, [426			("std", "type") => parse_args!(context, "std.type", args, 1, [
429				0, x, vec![];427				0, x, vec![];
430			], {428			], {
431				Val::Str(x.value_type()?.name().into())429				Ok(Val::Str(x.value_type()?.name().into()))
432			}),430			})?,
433			// length, idx=>any431			// length, idx=>any
434			("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [432			("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [
435				0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];433				0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];
436				1, func: [Val::Func]!!Val::Func, vec![ValType::Func];434				1, func: [Val::Func]!!Val::Func, vec![ValType::Func];
437			], {435			], {
438				if sz < 0.0 {436				if sz < 0.0 {
439					create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;437					throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));
440				}438				}
441				let mut out = Vec::with_capacity(sz as usize);439				let mut out = Vec::with_capacity(sz as usize);
442				for i in 0..sz as usize {440				for i in 0..sz as usize {
455					str.chars().count() == 1,453					str.chars().count() == 1,
456					"std.codepoint should receive single char string"454					"std.codepoint should receive single char string"
457				);455				);
458				Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)456				Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))
459			}),457			})?,
460			// object, includeHidden458			// object, includeHidden
461			("std", "objectFieldsEx") => {459			("std", "objectFieldsEx") => {
462				noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [460				noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [
478				1, f: [Val::Str]!!Val::Str, vec![ValType::Str];476				1, f: [Val::Str]!!Val::Str, vec![ValType::Str];
479				2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];477				2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];
480			], {478			], {
481				Val::Bool(479				Ok(Val::Bool(
482					obj.fields_visibility()480					obj.fields_visibility()
483						.into_iter()481						.into_iter()
484						.filter(|(_k, v)| *v || inc_hidden)482						.filter(|(_k, v)| *v || inc_hidden)
485						.any(|(k, _v)| *k == *f),483						.any(|(k, _v)| *k == *f),
486				)484				))
487			}),485			})?,
488			("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [486			("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [
489				0, a, vec![];487				0, a, vec![];
490				1, b, vec![];488				1, b, vec![];
491			], {489			], {
492				Val::Bool(primitive_equals(&a, &b)?)490				Ok(Val::Bool(primitive_equals(&a, &b)?))
493			}),491			})?,
494			// faster492			// faster
495			("std", "equals") => parse_args!(context, "std.equals", args, 2, [493			("std", "equals") => parse_args!(context, "std.equals", args, 2, [
496				0, a, vec![];494				0, a, vec![];
497				1, b, vec![];495				1, b, vec![];
498			], {496			], {
499				Val::Bool(equals(&a, &b)?)497				Ok(Val::Bool(equals(&a, &b)?))
500			}),498			})?,
501			("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [499			("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [
502				0, a: [Val::Num]!!Val::Num, vec![ValType::Num];500				0, a: [Val::Num]!!Val::Num, vec![ValType::Num];
503				1, b: [Val::Num]!!Val::Num, vec![ValType::Num];501				1, b: [Val::Num]!!Val::Num, vec![ValType::Num];
504			], {502			], {
505				Val::Num(a % b)503				Ok(Val::Num(a % b))
506			}),504			})?,
507			("std", "floor") => parse_args!(context, "std.floor", args, 1, [505			("std", "floor") => parse_args!(context, "std.floor", args, 1, [
508				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];506				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
509			], {507			], {
510				Val::Num(x.floor())508				Ok(Val::Num(x.floor()))
511			}),509			})?,
512			("std", "log") => parse_args!(context, "std.log", args, 2, [510			("std", "log") => parse_args!(context, "std.log", args, 2, [
513				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];511				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];
514			], {512			], {
515				Val::Num(n.ln())513				Ok(Val::Num(n.ln()))
516			}),514			})?,
517			("std", "trace") => parse_args!(context, "std.trace", args, 2, [515			("std", "trace") => parse_args!(context, "std.trace", args, 2, [
518				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];516				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
519				1, rest, vec![];517				1, rest, vec![];
526					});524					});
527				}525				}
528				eprintln!(" {}", str);526				eprintln!(" {}", str);
529				rest527				Ok(rest)
530			}),528			})?,
531			("std", "pow") => parse_args!(context, "std.modulo", args, 2, [529			("std", "pow") => parse_args!(context, "std.modulo", args, 2, [
532				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];530				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
533				1, n: [Val::Num]!!Val::Num, vec![ValType::Num];531				1, n: [Val::Num]!!Val::Num, vec![ValType::Num];
534			], {532			], {
535				Val::Num(x.powf(n))533				Ok(Val::Num(x.powf(n)))
536			}),534			})?,
537			("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [535			("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [
538				0, x: [Val::Str]!!Val::Str, vec![ValType::Str];536				0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
539			], {537			], {
540				with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(538				Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(
541					|| create_error(crate::Error::UndefinedExternalVariable(x)),539					|| UndefinedExternalVariable(x),
542				)?540				)?)
543			}),541			})?,
544			("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [542			("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [
545				0, func: [Val::Func]!!Val::Func, vec![ValType::Func];543				0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
546				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];544				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
583				Ok(acc)581				Ok(acc)
584			}))?,582			}))?,
585			// faster583			// faster
584			#[allow(non_snake_case)]
586			("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [585			("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [
587				0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];586				0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
588				1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];587				1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];
598							match keyF.evaluate_values(context.clone(), &[k.clone()]) {597							match keyF.evaluate_values(context.clone(), &[k.clone()]) {
599								Ok(Val::Str(v)) => v,598								Ok(Val::Str(v)) => v,
600								Ok(_) => {599								Ok(_) => {
601									err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));600									err = Some(LocError::new(RuntimeError("types of all array elements should equal".into())));
602									"".into()601									"".into()
603								}602								}
604								Err(e) => {603								Err(e) => {
617							match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {616							match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {
618								(Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),617								(Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),
619								(Ok(_a), Ok(_b)) => {618								(Ok(_a), Ok(_b)) => {
620									err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));619									err = Some(RuntimeError("types of all array elements should equal".into()).into());
621									Ordering::Equal620									Ordering::Equal
622								}621								}
623								(Err(e), _) | (_, Err(e)) => {622								(Err(e), _) | (_, Err(e)) => {
630							return Err(e);629							return Err(e);
631						}630						}
632					},631					},
633					_ => return Err(create_error(crate::error::Error::RuntimeError("keys should be number or string".into())))632					_ => throw!(RuntimeError("keys should be number or string".into()))
634				}633				}
635				Ok(Val::Arr(Rc::new(new_arr)))634				Ok(Val::Arr(Rc::new(new_arr)))
636			}))?,635			}))?,
637			// faster636			// faster
638			("std", "format") => parse_args!(context, "std.format", args, 2, [637			("std", "format") => parse_args!(context, "std.format", args, 2, [
639				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];638				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
640				1, vals: [Val::Arr|Val::Obj], vec![ValType::Arr, ValType::Obj];639				1, vals, vec![]
641			], {640			], {
641				push(&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)), ||format!("std.format of {}", str), ||{
642				match vals {642					Ok(match vals {
643					Val::Arr(vals) => Val::Str(format_arr(&str, &vals).unwrap().into()),643						Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),
644					Val::Obj(obj) => Val::Str(format_obj(&str, &obj).unwrap().into()),644						Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),
645					_ => unreachable!()645						o => Val::Str(format_arr(&str, &[o])?.into()),
646				}646					})
647				})
647			}),648			})?,
648			// faster649			// faster
649			("std", "range") => parse_args!(context, "std.range", args, 2, [650			("std", "range") => parse_args!(context, "std.range", args, 2, [
650				0, from: [Val::Num]!!Val::Num, vec![ValType::Num];651				0, from: [Val::Num]!!Val::Num, vec![ValType::Num];
654				for i in from as usize..=to as usize {655				for i in from as usize..=to as usize {
655					out.push(Val::Num(i as f64));656					out.push(Val::Num(i as f64));
656				}657				}
657				Val::Arr(Rc::new(out))658				Ok(Val::Arr(Rc::new(out)))
658			}),659			})?,
659			("std", "char") => parse_args!(context, "std.char", args, 1, [660			("std", "char") => parse_args!(context, "std.char", args, 1, [
660				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];661				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];
661			], {662			], {
662				let mut out = String::new();663				let mut out = String::new();
663				out.push(std::char::from_u32(n as u32).ok_or_else(||664				out.push(std::char::from_u32(n as u32).ok_or_else(||
664					create_error(crate::error::Error::InvalidUnicodeCodepointGot(n as u32))665					InvalidUnicodeCodepointGot(n as u32)
665				)?);666				)?);
666				Ok(Val::Str(out.into()))667				Ok(Val::Str(out.into()))
667			})?,668			})?,
668			("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [669			("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [
669				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];670				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
670			], {671			], {
671				Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))672				Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))
672			}),673			})?,
673			("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [674			("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [
674				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];675				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
675			], {676			], {
679			("std", "base64") => parse_args!(context, "std.base64", args, 1, [680			("std", "base64") => parse_args!(context, "std.base64", args, 1, [
680				0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];681				0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];
681			], {682			], {
682				Val::Str(match input {683				Ok(Val::Str(match input {
683					Val::Str(s) => {684					Val::Str(s) => {
684						base64::encode(s.bytes().collect::<Vec<_>>()).into()685						base64::encode(s.bytes().collect::<Vec<_>>()).into()
685					},686					},
689						}).collect::<Result<Vec<_>>>()?).into()690						}).collect::<Result<Vec<_>>>()?).into()
690					},691					},
691					_ => unreachable!()692					_ => unreachable!()
692				})693				}))
693			}),694			})?,
694			// faster695			// faster
695			("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [696			("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [
696				0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];697				0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];
711								out.reserve(items.len());712								out.reserve(items.len());
712								out.extend(items.iter().cloned());713								out.extend(items.iter().cloned());
713							} else {714							} else {
714								create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;715								throw!(RuntimeError("in std.join all items should be arrays".into()));
715							}716							}
716						}717						}
717718
729								first = false;730								first = false;
730								out += &item;731								out += &item;
731							} else {732							} else {
732								create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;733								throw!(RuntimeError("in std.join all items should be strings".into()));
733							}734							}
734						}735						}
735736
742			("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [743			("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [
743				0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];744				0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];
744			], {745			], {
745				Val::Str(escape_string_json(&str_).into())746				Ok(Val::Str(escape_string_json(&str_).into()))
746			}),747			})?,
747			// Faster748			// Faster
748			("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [749			("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [
749				0, value, vec![];750				0, value, vec![];
750				1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];751				1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];
751			], {752			], {
752				Val::Str(manifest_json_ex(&value, &indent)?.into())753				Ok(Val::Str(manifest_json_ex(&value, &indent)?.into()))
753			}),754			})?,
754			(ns, name) => {755			(ns, name) => throw!(IntristicNotFound(ns.into(), name.into())),
755				create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?
756			}
757		},756		},
758		Val::Func(f) => {757		Val::Func(f) => {
759			let body = || f.evaluate(context, args, tailstrict);758			let body = || f.evaluate(context, args, tailstrict);
763				push(loc, || format!("function <{}> call", f.name), body)?762				push(loc, || format!("function <{}> call", f.name), body)?
764			}763			}
765		}764		}
766		v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,765		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),
767	})766	})
768}767}
769768
784			context783			context
785				.this()784				.this()
786				.clone()785				.clone()
787				.ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,786				.ok_or_else(|| CantUseSelfOutsideOfObject)?,
788		),787		),
789		Literal(LiteralType::Dollar) => Val::Obj(788		Literal(LiteralType::Dollar) => Val::Obj(
790			context789			context
791				.dollar()790				.dollar()
792				.clone()791				.clone()
793				.ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,792				.ok_or_else(|| NoTopLevelObjectFound)?,
794		),793		),
795		Literal(LiteralType::True) => Val::Bool(true),794		Literal(LiteralType::True) => Val::Bool(true),
796		Literal(LiteralType::False) => Val::Bool(false),795		Literal(LiteralType::False) => Val::Bool(false),
825					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {824					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {
826						Val::Intristic(n, s)825						Val::Intristic(n, s)
827					} else {826					} else {
828						create_error_result(crate::Error::NoSuchField(s))?827						throw!(NoSuchField(s))
829					}828					}
830				}829				}
831				(Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(830				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
832					ValType::Obj,831					ValType::Obj,
833					ValType::Str,832					ValType::Str,
834					n.value_type()?,833					n.value_type()?,
835				))?,834				)),
836835
837				(Val::Arr(v), Val::Num(n)) => {836				(Val::Arr(v), Val::Num(n)) => {
838					if n.fract() > f64::EPSILON {837					if n.fract() > f64::EPSILON {
839						create_error_result(crate::Error::FractionalIndex)?838						throw!(FractionalIndex)
840					}839					}
841					v.get(n as usize)840					v.get(n as usize)
842						.ok_or_else(|| {841						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
843							create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))
844						})?
845						.clone()842						.clone()
846						.unwrap_if_lazy()?843						.unwrap_if_lazy()?
847				}844				}
848				(Val::Arr(_), Val::Str(n)) => {845				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),
849					create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?
850				}
851				(Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(846				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
852					ValType::Arr,847					ValType::Arr,
853					ValType::Num,848					ValType::Num,
854					n.value_type()?,849					n.value_type()?,
855				))?,850				)),
856851
857				(Val::Str(s), Val::Num(n)) => Val::Str(852				(Val::Str(s), Val::Num(n)) => Val::Str(
858					s.chars()853					s.chars()
861						.collect::<String>()856						.collect::<String>()
862						.into(),857						.into(),
863				),858				),
864				(Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(859				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
865					ValType::Str,860					ValType::Str,
866					ValType::Num,861					ValType::Num,
867					n.value_type()?,862					n.value_type()?,
868				))?,863				)),
869864
870				(v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,865				(v, _) => throw!(CantIndexInto(v.value_type()?)),
871			}866			}
872		}867		}
873		LocalExpr(bindings, returned) => {868		LocalExpr(bindings, returned) => {
926			if assertion_result {921			if assertion_result {
927				evaluate(context, returned)?922				evaluate(context, returned)?
928			} else if let Some(msg) = msg {923			} else if let Some(msg) = msg {
929				create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?924				throw!(AssertionFailed(evaluate(context, msg)?));
930			} else {925			} else {
931				create_error_result(crate::Error::AssertionFailed(Val::Null))?926				throw!(AssertionFailed(Val::Null));
932			}927			}
933		}928		}
934		Error(e) => push(929		ErrorStmt(e) => push(
935			&loc,930			&loc,
936			|| "error statement".to_owned(),931			|| "error statement".to_owned(),
937			|| {932			|| {
938				create_error_result(crate::Error::RuntimeError(933				throw!(RuntimeError(
939					evaluate(context, e)?.try_cast_str("error text should be string")?,934					evaluate(context, e)?.try_cast_str("error text should be string")?,
940				))?935				))
941			},936			},
942		)?,937		)?,
943		IfElse {938		IfElse {
978			import_location.pop();973			import_location.pop();
979			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)974			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)
980		}975		}
981		Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),976		Literal(LiteralType::Super) => throw!(StandaloneSuper),
982	})977	})
983}978}
984979
modifiedcrates/jrsonnet-evaluator/src/function.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -1,7 +1,4 @@
-use crate::{
-	create_error, create_error_result, evaluate, lazy_val, resolved_lazy_val, Context, Error,
-	Result, Val,
-};
+use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};
 use closure::closure;
 use jrsonnet_parser::{ArgsDesc, ParamsDesc};
 use std::{collections::HashMap, rc::Rc};
@@ -30,16 +27,16 @@
 			params
 				.iter()
 				.position(|p| *p.0 == *name)
-				.ok_or_else(|| create_error(Error::UnknownFunctionParameter(name.clone())))?
+				.ok_or_else(|| UnknownFunctionParameter(name.clone()))?
 		} else {
 			id
 		};
 
 		if idx >= params.len() {
-			create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+			throw!(TooManyArgsFunctionHas(params.len()));
 		}
 		if positioned_args[idx].is_some() {
-			create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;
+			throw!(BindingParameterASecondTime(params[idx].0.clone()));
 		}
 		positioned_args[idx] = Some(arg.1.clone());
 	}
@@ -50,8 +47,7 @@
 		} else if let Some(default) = &p.1 {
 			(body_ctx.clone().expect(NO_DEFAULT_CONTEXT), default)
 		} else {
-			create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
-			unreachable!()
+			throw!(FunctionParameterNotBoundInCall(p.0.clone()));
 		};
 		let val = if tailstrict {
 			resolved_lazy_val!(evaluate(ctx, expr)?)
@@ -74,15 +70,16 @@
 	let mut out = HashMap::new();
 	let mut positioned_args = vec![None; params.0.len()];
 	for (name, val) in args.iter() {
-		let idx = params.iter().position(|p| *p.0 == **name).ok_or_else(|| {
-			create_error(Error::UnknownFunctionParameter((&name as &str).to_owned()))
-		})?;
+		let idx = params
+			.iter()
+			.position(|p| *p.0 == **name)
+			.ok_or_else(|| UnknownFunctionParameter((&name as &str).to_owned()))?;
 
 		if idx >= params.len() {
-			create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+			throw!(TooManyArgsFunctionHas(params.len()));
 		}
 		if positioned_args[idx].is_some() {
-			create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;
+			throw!(BindingParameterASecondTime(params[idx].0.clone()));
 		}
 		positioned_args[idx] = Some(val.clone());
 	}
@@ -104,8 +101,7 @@
 				})
 			}
 		} else {
-			create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
-			unreachable!()
+			throw!(FunctionParameterNotBoundInCall(p.0.clone()));
 		};
 		out.insert(p.0.clone(), val);
 	}
@@ -123,7 +119,7 @@
 	let mut positioned_args = vec![None; params.0.len()];
 	for (id, arg) in args.iter().enumerate() {
 		if id >= params.len() {
-			create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+			throw!(TooManyArgsFunctionHas(params.len()));
 		}
 		positioned_args[id] = Some(arg);
 	}
@@ -134,8 +130,7 @@
 		} else if let Some(default) = &p.1 {
 			evaluate(ctx.clone(), default)?
 		} else {
-			create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
-			unreachable!()
+			throw!(FunctionParameterNotBoundInCall(p.0.clone()));
 		};
 		out.insert(p.0.clone(), resolved_lazy_val!(val));
 	}
@@ -148,36 +143,39 @@
 	($ctx: expr, $fn_name: expr, $args: expr, $total_args: expr, [
 		$($id: expr, $name: ident $(: [$($p: path)|+] $(!! $a: path)?)?, $nt: expr);+ $(;)?
 	], $handler:block) => {{
-		use crate::Error;
+		use crate::{throw, error::Error::*};
 		let args = $args;
 		if args.len() > $total_args {
-			create_error_result(Error::TooManyArgsFunctionHas($total_args))?;
+			throw!(TooManyArgsFunctionHas($total_args));
 		}
 		$(
 			if args.len() <= $id {
-				create_error_result(Error::FunctionParameterNotBoundInCall(stringify!($name).into()))?;
+				throw!(FunctionParameterNotBoundInCall(stringify!($name).into()));
 			}
 			let $name = &args[$id];
 			if $name.0.is_some() {
 				if $name.0.as_ref().unwrap() != stringify!($name) {
-					create_error_result(Error::IntristicArgumentReorderingIsNotSupportedYet)?;
+					throw!(IntristicArgumentReorderingIsNotSupportedYet);
 				}
 			}
 			let $name = evaluate($ctx.clone(), &$name.1)?;
 			$(
 				match $name {
 					$($p(_))|+ => {},
-					_ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,
+					_ => throw!(TypeMismatch(
+						concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"),
+						$nt, $name.value_type()?
+					)),
 				};
 				$(
 					let $name = match $name {
 						$a(v) => v,
-						_ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,
+						_ =>throw!(TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?)),
 					};
 				)*
 			)*
 		)+
-		$handler
+		($handler as crate::Result<_>)
 	}};
 }
 
@@ -198,7 +196,9 @@
 		], {
 			assert!((a - 2.0).abs() <= f64::EPSILON);
 			assert!((b - 1.0).abs() <= f64::EPSILON);
-		});
+			Ok(())
+		})
+		.unwrap();
 		Ok(())
 	})
 }
modifiedcrates/jrsonnet-evaluator/src/import.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -1,7 +1,6 @@
-use crate::create_error_result;
 use crate::{
-	create_error,
-	error::{Error, Result},
+	error::{Error::*, Result},
+	throw,
 };
 use fs::File;
 use std::fs;
@@ -28,7 +27,7 @@
 pub struct DummyImportResolver;
 impl ImportResolver for DummyImportResolver {
 	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
-		create_error_result(Error::ImportNotSupported(from.clone(), path.clone()))
+		throw!(ImportNotSupported(from.clone(), path.clone()))
 	}
 	fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {
 		// Can be only caused by library direct consumer, not by supplied jsonnet
@@ -65,15 +64,14 @@
 					return Ok(Rc::new(cloned));
 				}
 			}
-			create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))
+			throw!(ImportFileNotFound(from.clone(), path.clone()))
 		}
 	}
 	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
-		let mut file =
-			File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;
+		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
 		let mut out = String::new();
 		file.read_to_string(&mut out)
-			.map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;
+			.map_err(|_e| ImportBadFileUtf8(id.clone()))?;
 		Ok(out.into())
 	}
 	unsafe fn as_any(&self) -> &dyn Any {
modifiedcrates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -10,7 +10,7 @@
 mod builtin;
 mod ctx;
 mod dynamic;
-mod error;
+pub mod error;
 mod evaluate;
 mod function;
 mod import;
@@ -21,7 +21,7 @@
 
 pub use ctx::*;
 pub use dynamic::*;
-pub use error::*;
+use error::{Error::*, LocError, Result, StackTraceElement};
 pub use evaluate::*;
 pub use function::parse_function_call;
 pub use import::*;
@@ -131,13 +131,7 @@
 }
 pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {
 	EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))
-}
-pub fn create_error(err: Error) -> LocError {
-	LocError(err, StackTrace(vec![]))
 }
-pub fn create_error_result<T>(err: Error) -> Result<T> {
-	Err(LocError(err, StackTrace(vec![])))
-}
 pub(crate) fn push<T>(
 	e: &Option<ExprLocation>,
 	frame_desc: impl FnOnce() -> String,
@@ -167,12 +161,10 @@
 					loc_data: true,
 				},
 			)
-			.map_err(|error| {
-				create_error(Error::ImportSyntaxError {
-					error,
-					path,
-					source_code,
-				})
+			.map_err(|error| ImportSyntaxError {
+				error,
+				path,
+				source_code,
 			})?,
 		)?;
 
@@ -292,7 +284,7 @@
 			if *stack_depth > self.max_stack() {
 				// Error creation uses data, so i drop guard here
 				drop(data);
-				return Err(create_error(Error::StackOverflow));
+				throw!(StackOverflow);
 			} else {
 				*stack_depth += 1;
 			}
@@ -340,7 +332,7 @@
 				ManifestFormat::Json(padding) => val.into_json(padding)?,
 				ManifestFormat::None => match val {
 					Val::Str(s) => s,
-					_ => return Err(create_error(Error::StringManifestOutputIsNotAString)),
+					_ => throw!(StringManifestOutputIsNotAString),
 				},
 			})
 		})
@@ -476,7 +468,7 @@
 #[cfg(test)]
 pub mod tests {
 	use super::Val;
-	use crate::{create_error, primitive_equals, EvaluationState};
+	use crate::{error::Error::*, primitive_equals, EvaluationState};
 	use jrsonnet_parser::*;
 	use std::{path::PathBuf, rc::Rc};
 
@@ -493,7 +485,7 @@
 						state.push(
 							&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
 							|| "inner".to_owned(),
-							|| Err(create_error(crate::error::Error::RuntimeError("".into()))),
+							|| Err(RuntimeError("".into()).into()),
 						)?;
 						Ok(())
 					},
modifiedcrates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -11,11 +11,13 @@
 	pub location: Option<ExprLocation>,
 }
 
+// Field => This
+type CacheKey = (Rc<str>, usize);
 #[derive(Debug)]
 pub struct ObjValueInternals {
 	super_obj: Option<ObjValue>,
 	this_entries: Rc<HashMap<Rc<str>, ObjMember>>,
-	value_cache: RefCell<HashMap<(Rc<str>, usize), Option<Val>>>,
+	value_cache: RefCell<HashMap<CacheKey, Option<Val>>>,
 }
 #[derive(Clone)]
 pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);
modifiedcrates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -1,7 +1,8 @@
 use crate::{
-	create_error_result, evaluate,
+	error::Error::*,
+	evaluate,
 	function::{parse_function_call, parse_function_call_map, place_args},
-	with_state, Context, Error, ObjValue, Result,
+	throw, with_state, Context, ObjValue, Result,
 };
 use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};
 use std::{
@@ -157,14 +158,14 @@
 		if num.is_finite() {
 			Ok(Val::Num(num))
 		} else {
-			create_error_result(Error::RuntimeError("overflow".into()))
+			throw!(RuntimeError("overflow".into()))
 		}
 	}
 
 	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {
 		let this_type = self.value_type()?;
 		if this_type != val_type {
-			create_error_result(Error::TypeMismatch(context, vec![val_type], this_type))
+			throw!(TypeMismatch(context, vec![val_type], this_type))
 		} else {
 			Ok(())
 		}
@@ -263,15 +264,15 @@
 		(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(_)) => create_error_result(Error::RuntimeError(
+		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(
 			"primitiveEquals operates on primitive types, got array".into(),
-		))?,
-		(Val::Obj(_), Val::Obj(_)) => create_error_result(Error::RuntimeError(
+		)),
+		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(
 			"primitiveEquals operates on primitive types, got object".into(),
-		))?,
-		(a, b) if is_function_like(&a) && is_function_like(&b) => create_error_result(
-			Error::RuntimeError("cannot test equality of functions".into()),
-		)?,
+		)),
+		(a, b) if is_function_like(&a) && is_function_like(&b) => {
+			throw!(RuntimeError("cannot test equality of functions".into()))
+		}
 		(_, _) => false,
 	})
 }
@@ -376,7 +377,7 @@
 			buf.push('}');
 		}
 		Val::Func(_) | Val::Intristic(_, _) => {
-			create_error_result(Error::RuntimeError("tried to manifest function".into()))?
+			throw!(RuntimeError("tried to manifest function".into()))
 		}
 		Val::Lazy(_) => unreachable!(),
 	};
modifiedcrates/jrsonnet-parser/src/expr.rsdiffbeforeafterboth
--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -258,7 +258,7 @@
 	/// importStr "file.txt"
 	ImportStr(PathBuf),
 	/// error "I'm broken"
-	Error(LocExpr),
+	ErrorStmt(LocExpr),
 	/// a(b, c)
 	Apply(LocExpr, ArgsDesc, bool),
 	/// a[b]
modifiedcrates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -197,7 +197,7 @@
 			/ l(s,<keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}>)
 			/ l(s,<assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }>)
 
-			/ l(s,<keyword("error") _ expr:expr(s) { Expr::Error(expr) }>)
+			/ l(s,<keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }>)
 
 		rule slice_part(s: &ParserSettings) -> Option<LocExpr>
 			= e:(_ e:expr(s) _{e})? {e}