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

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -15,7 +15,7 @@
 
 use jrsonnet_evaluator::{
 	error::{Error::*, Result},
-	throw, EvaluationState, ImportResolver,
+	throw, ImportResolver, State,
 };
 
 pub type JsonnetImportCallback = unsafe extern "C" fn(
@@ -87,7 +87,7 @@
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_import_callback(
-	vm: &EvaluationState,
+	vm: &State,
 	cb: JsonnetImportCallback,
 	ctx: *mut c_void,
 ) {
@@ -141,7 +141,7 @@
 ///
 /// This function is safe, if received v is a pointer to normal C string
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_jpath_add(vm: &EvaluationState, v: *const c_char) {
+pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, v: *const c_char) {
 	let cstr = CStr::from_ptr(v);
 	let path = PathBuf::from(cstr.to_str().unwrap());
 	let any_resolver = &vm.settings().import_resolver;

--- a/bindings/jsonnet/src/interop.rs
+++ b/bindings/jsonnet/src/interop.rs
@@ -5,7 +5,7 @@
 	os::raw::{c_char, c_int},
 };
 
-use jrsonnet_evaluator::{EvaluationState, Val};
+use jrsonnet_evaluator::{State, Val};
 
 use crate::{import::jsonnet_import_callback, native::jsonnet_native_callback};
 
@@ -28,17 +28,14 @@
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(
-	vm: &EvaluationState,
-	ctx: *mut c_void,
-) {
+pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(vm: &State, ctx: *mut c_void) {
 	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)
 }
 
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(
-	vm: &EvaluationState,
+	vm: &State,
 	name: *const c_char,
 	ctx: *mut c_void,
 	raw_params: *const *const c_char,
@@ -47,7 +44,7 @@
 }
 
 #[no_mangle]
-pub extern "C" fn jrsonnet_set_trace_format(vm: &EvaluationState, format: u8) {
+pub extern "C" fn jrsonnet_set_trace_format(vm: &State, format: u8) {
 	use jrsonnet_evaluator::trace::JsFormat;
 	match format {
 		1 => vm.set_trace_format(Box::new(JsFormat)),

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -16,7 +16,7 @@
 };
 
 use import::NativeImportResolver;
-use jrsonnet_evaluator::{EvaluationState, IStr, ManifestFormat, Val};
+use jrsonnet_evaluator::{IStr, ManifestFormat, State, Val};
 
 /// WASM stub
 #[cfg(target_arch = "wasm32")]
@@ -29,8 +29,8 @@
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_make() -> *mut EvaluationState {
-	let state = EvaluationState::default();
+pub extern "C" fn jsonnet_make() -> *mut State {
+	let state = State::default();
 	state.with_stdlib();
 	state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());
 	Box::into_raw(Box::new(state))
@@ -39,23 +39,23 @@
 /// # Safety
 #[no_mangle]
 #[allow(clippy::boxed_local)]
-pub unsafe extern "C" fn jsonnet_destroy(vm: *mut EvaluationState) {
+pub unsafe extern "C" fn jsonnet_destroy(vm: *mut State) {
 	Box::from_raw(vm);
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {
+pub extern "C" fn jsonnet_max_stack(vm: &State, v: c_uint) {
 	vm.settings_mut().max_stack = v as usize;
 }
 
 // jrsonnet currently have no GC, so these functions is no-op
 #[no_mangle]
-pub extern "C" fn jsonnet_gc_min_objects(_vm: &EvaluationState, _v: c_uint) {}
+pub extern "C" fn jsonnet_gc_min_objects(_vm: &State, _v: c_uint) {}
 #[no_mangle]
-pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &EvaluationState, _v: c_double) {}
+pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &State, _v: c_double) {}
 
 #[no_mangle]
-pub extern "C" fn jsonnet_string_output(vm: &EvaluationState, v: c_int) {
+pub extern "C" fn jsonnet_string_output(vm: &State, v: c_int) {
 	match v {
 		1 => vm.set_manifest_format(ManifestFormat::String),
 		0 => vm.set_manifest_format(ManifestFormat::Json {
@@ -71,11 +71,7 @@
 ///
 /// This function is most definitely broken, but it works somehow, see TODO inside
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_realloc(
-	_vm: &EvaluationState,
-	buf: *mut u8,
-	sz: usize,
-) -> *mut u8 {
+pub unsafe extern "C" fn jsonnet_realloc(_vm: &State, buf: *mut u8, sz: usize) -> *mut u8 {
 	if buf.is_null() {
 		assert!(sz != 0);
 		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());
@@ -95,12 +91,12 @@
 /// # Safety
 #[no_mangle]
 #[allow(clippy::boxed_local)]
-pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &EvaluationState, v: *mut Val) {
+pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &State, v: *mut Val) {
 	Box::from_raw(v);
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_max_trace(vm: &EvaluationState, v: c_uint) {
+pub extern "C" fn jsonnet_max_trace(vm: &State, v: c_uint) {
 	vm.set_max_trace(v as usize)
 }
 
@@ -109,28 +105,26 @@
 /// This function is safe, if received v is a pointer to normal C string
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_file(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		match vm
-			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				CString::new(&*v as &str).unwrap().into_raw()
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	match vm
+		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			CString::new(&*v as &str).unwrap().into_raw()
+		}
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
 		}
-	})
+	}
 }
 
 /// # Safety
@@ -138,33 +132,31 @@
 /// This function is safe, if received v is a pointer to normal C string
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_snippet(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	snippet: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		let snippet = CStr::from_ptr(snippet);
-		match vm
-			.evaluate_snippet_raw(
-				PathBuf::from(filename.to_str().unwrap()).into(),
-				snippet.to_str().unwrap().into(),
-			)
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				CString::new(&*v as &str).unwrap().into_raw()
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	let snippet = CStr::from_ptr(snippet);
+	match vm
+		.evaluate_snippet_raw(
+			PathBuf::from(filename.to_str().unwrap()).into(),
+			snippet.to_str().unwrap().into(),
+		)
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			CString::new(&*v as &str).unwrap().into_raw()
 		}
-	})
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
+		}
+	}
 }
 
 fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {
@@ -187,60 +179,56 @@
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_file_multi(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		match vm
-			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest_multi(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				multi_to_raw(v)
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	match vm
+		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest_multi(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			multi_to_raw(v)
+		}
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
 		}
-	})
+	}
 }
 
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	snippet: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		let snippet = CStr::from_ptr(snippet);
-		match vm
-			.evaluate_snippet_raw(
-				PathBuf::from(filename.to_str().unwrap()).into(),
-				snippet.to_str().unwrap().into(),
-			)
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest_multi(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				multi_to_raw(v)
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	let snippet = CStr::from_ptr(snippet);
+	match vm
+		.evaluate_snippet_raw(
+			PathBuf::from(filename.to_str().unwrap()).into(),
+			snippet.to_str().unwrap().into(),
+		)
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest_multi(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			multi_to_raw(v)
+		}
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
 		}
-	})
+	}
 }
 
 fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {
@@ -261,58 +249,54 @@
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_file_stream(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		match vm
-			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest_stream(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				stream_to_raw(v)
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	match vm
+		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest_stream(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			stream_to_raw(v)
+		}
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
 		}
-	})
+	}
 }
 
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(
-	vm: &EvaluationState,
+	vm: &State,
 	filename: *const c_char,
 	snippet: *const c_char,
 	error: &mut c_int,
 ) -> *const c_char {
-	vm.run_in_state(|| {
-		let filename = CStr::from_ptr(filename);
-		let snippet = CStr::from_ptr(snippet);
-		match vm
-			.evaluate_snippet_raw(
-				PathBuf::from(filename.to_str().unwrap()).into(),
-				snippet.to_str().unwrap().into(),
-			)
-			.and_then(|v| vm.with_tla(v))
-			.and_then(|v| vm.manifest_stream(v))
-		{
-			Ok(v) => {
-				*error = 0;
-				stream_to_raw(v)
-			}
-			Err(e) => {
-				*error = 1;
-				let out = vm.stringify_err(&e);
-				CString::new(&out as &str).unwrap().into_raw()
-			}
+	let filename = CStr::from_ptr(filename);
+	let snippet = CStr::from_ptr(snippet);
+	match vm
+		.evaluate_snippet_raw(
+			PathBuf::from(filename.to_str().unwrap()).into(),
+			snippet.to_str().unwrap().into(),
+		)
+		.and_then(|v| vm.with_tla(v))
+		.and_then(|v| vm.manifest_stream(v))
+	{
+		Ok(v) => {
+			*error = 0;
+			stream_to_raw(v)
 		}
-	})
+		Err(e) => {
+			*error = 1;
+			let out = vm.stringify_err(&e);
+			CString::new(&out as &str).unwrap().into_raw()
+		}
+	}
 }

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -1,5 +1,4 @@
 use std::{
-	convert::TryFrom,
 	ffi::{c_void, CStr},
 	os::raw::{c_char, c_int},
 	path::Path,
@@ -12,7 +11,8 @@
 	function::BuiltinParam,
 	gc::TraceBox,
 	native::{NativeCallback, NativeCallbackHandler},
-	EvaluationState, IStr, Val,
+	typed::Typed,
+	IStr, State, Val,
 };
 
 type JsonnetNativeCallback = unsafe extern "C" fn(
@@ -29,7 +29,7 @@
 	cb: JsonnetNativeCallback,
 }
 impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
-	fn call(&self, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {
+	fn call(&self, s: State, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {
 		let mut n_args = Vec::new();
 		for a in args {
 			n_args.push(Some(Box::new(a.clone())));
@@ -47,7 +47,7 @@
 		if success == 1 {
 			Ok(v)
 		} else {
-			let e = IStr::try_from(v).expect("error msg");
+			let e = IStr::from_untyped(v, s).expect("error msg");
 			Err(Error::RuntimeError(e).into())
 		}
 	}
@@ -56,7 +56,7 @@
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_native_callback(
-	vm: &EvaluationState,
+	vm: &State,
 	name: *const c_char,
 	cb: JsonnetNativeCallback,
 	ctx: *const c_void,

--- a/bindings/jsonnet/src/val_extract.rs
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -5,21 +5,17 @@
 	os::raw::{c_char, c_double, c_int},
 };
 
-use jrsonnet_evaluator::{EvaluationState, Val};
+use jrsonnet_evaluator::{State, Val};
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {
+pub extern "C" fn jsonnet_json_extract_string(_vm: &State, v: &Val) -> *mut c_char {
 	match v {
 		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
 		_ => std::ptr::null_mut(),
 	}
 }
 #[no_mangle]
-pub extern "C" fn jsonnet_json_extract_number(
-	_vm: &EvaluationState,
-	v: &Val,
-	out: &mut c_double,
-) -> c_int {
+pub extern "C" fn jsonnet_json_extract_number(_vm: &State, v: &Val, out: &mut c_double) -> c_int {
 	match v {
 		Val::Num(n) => {
 			*out = *n;
@@ -29,7 +25,7 @@
 	}
 }
 #[no_mangle]
-pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {
+pub extern "C" fn jsonnet_json_extract_bool(_vm: &State, v: &Val) -> c_int {
 	match v {
 		Val::Bool(false) => 0,
 		Val::Bool(true) => 1,
@@ -37,7 +33,7 @@
 	}
 }
 #[no_mangle]
-pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {
+pub extern "C" fn jsonnet_json_extract_null(_vm: &State, v: &Val) -> c_int {
 	match v {
 		Val::Null => 1,
 		_ => 0,

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -6,43 +6,40 @@
 };
 
 use gcmodule::Cc;
-use jrsonnet_evaluator::{val::ArrValue, EvaluationState, ObjValue, Val};
+use jrsonnet_evaluator::{val::ArrValue, ObjValue, State, Val};
 
 /// # Safety
 ///
 /// This function is safe, if received v is a pointer to normal C string
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_json_make_string(
-	_vm: &EvaluationState,
-	v: *const c_char,
-) -> *mut Val {
+pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &State, v: *const c_char) -> *mut Val {
 	let cstr = CStr::from_ptr(v);
 	let str = cstr.to_str().unwrap();
 	Box::into_raw(Box::new(Val::Str(str.into())))
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_make_number(_vm: &EvaluationState, v: c_double) -> *mut Val {
+pub extern "C" fn jsonnet_json_make_number(_vm: &State, v: c_double) -> *mut Val {
 	Box::into_raw(Box::new(Val::Num(v)))
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_make_bool(_vm: &EvaluationState, v: c_int) -> *mut Val {
+pub extern "C" fn jsonnet_json_make_bool(_vm: &State, v: c_int) -> *mut Val {
 	assert!(v == 0 || v == 1);
 	Box::into_raw(Box::new(Val::Bool(v == 1)))
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_make_null(_vm: &EvaluationState) -> *mut Val {
+pub extern "C" fn jsonnet_json_make_null(_vm: &State) -> *mut Val {
 	Box::into_raw(Box::new(Val::Null))
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {
+pub extern "C" fn jsonnet_json_make_array(_vm: &State) -> *mut Val {
 	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Cc::new(Vec::new())))))
 }
 
 #[no_mangle]
-pub extern "C" fn jsonnet_json_make_object(_vm: &EvaluationState) -> *mut Val {
+pub extern "C" fn jsonnet_json_make_object(_vm: &State) -> *mut Val {
 	Box::into_raw(Box::new(Val::Obj(ObjValue::new_empty())))
 }

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -5,17 +5,13 @@
 use std::{ffi::CStr, os::raw::c_char};
 
 use gcmodule::Cc;
-use jrsonnet_evaluator::{val::ArrValue, EvaluationState, LazyVal, Val};
+use jrsonnet_evaluator::{val::ArrValue, LazyVal, State, Val};
 
 /// # Safety
 ///
 /// Received arr value should be correct pointer to array allocated by make_array
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_json_array_append(
-	_vm: &EvaluationState,
-	arr: &mut Val,
-	val: &Val,
-) {
+pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &State, arr: &mut Val, val: &Val) {
 	match arr {
 		Val::Arr(old) => {
 			let mut new = Vec::new();
@@ -34,7 +30,7 @@
 /// This function is safe if passed name is ok
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_json_object_append(
-	_vm: &EvaluationState,
+	_vm: &State,
 	obj: &mut Val,
 	name: *const c_char,
 	val: &Val,

--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -2,15 +2,11 @@
 
 use std::{ffi::CStr, os::raw::c_char};
 
-use jrsonnet_evaluator::EvaluationState;
+use jrsonnet_evaluator::State;
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_ext_var(
-	vm: &EvaluationState,
-	name: *const c_char,
-	value: *const c_char,
-) {
+pub unsafe extern "C" fn jsonnet_ext_var(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
 	vm.add_ext_str(
@@ -21,11 +17,7 @@
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_ext_code(
-	vm: &EvaluationState,
-	name: *const c_char,
-	value: *const c_char,
-) {
+pub unsafe extern "C" fn jsonnet_ext_code(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
 	vm.add_ext_code(
@@ -36,11 +28,7 @@
 }
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_tla_var(
-	vm: &EvaluationState,
-	name: *const c_char,
-	value: *const c_char,
-) {
+pub unsafe extern "C" fn jsonnet_tla_var(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
 	vm.add_tla_str(
@@ -50,11 +38,7 @@
 }
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn jsonnet_tla_code(
-	vm: &EvaluationState,
-	name: *const c_char,
-	value: *const c_char,
-) {
+pub unsafe extern "C" fn jsonnet_tla_code(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
 	vm.add_tla_code(

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -7,7 +7,7 @@
 use clap::{AppSettings, IntoApp, Parser};
 use clap_complete::Shell;
 use jrsonnet_cli::{ConfigureState, GcOpts, GeneralOpts, InputOpts, ManifestOpts, OutputOpts};
-use jrsonnet_evaluator::{error::LocError, EvaluationState};
+use jrsonnet_evaluator::{error::LocError, State};
 
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
@@ -102,10 +102,10 @@
 
 fn main_catch(opts: Opts) -> bool {
 	let _printer = opts.gc.stats_printer();
-	let state = EvaluationState::default();
-	if let Err(e) = main_real(&state, opts) {
+	let s = State::default();
+	if let Err(e) = main_real(&s, opts) {
 		if let Error::Evaluation(e) = e {
-			eprintln!("{}", state.stringify_err(&e));
+			eprintln!("{}", s.stringify_err(&e));
 		} else {
 			eprintln!("{}", e);
 		}
@@ -114,13 +114,13 @@
 	true
 }
 
-fn main_real(state: &EvaluationState, opts: Opts) -> Result<(), Error> {
+fn main_real(s: &State, opts: Opts) -> Result<(), Error> {
 	opts.gc.configure_global();
-	opts.general.configure(state)?;
-	opts.manifest.configure(state)?;
+	opts.general.configure(s)?;
+	opts.manifest.configure(s)?;
 
 	let val = if opts.input.exec {
-		state.evaluate_snippet_raw(
+		s.evaluate_snippet_raw(
 			PathBuf::from("<cmdline>").into(),
 			(&opts.input.input as &str).into(),
 		)?
@@ -128,12 +128,12 @@
 		let mut input = Vec::new();
 		std::io::stdin().read_to_end(&mut input)?;
 		let input_str = std::str::from_utf8(&input)?.into();
-		state.evaluate_snippet_raw(PathBuf::from("<stdin>").into(), input_str)?
+		s.evaluate_snippet_raw(PathBuf::from("<stdin>").into(), input_str)?
 	} else {
-		state.evaluate_file_raw(&PathBuf::from(opts.input.input))?
+		s.evaluate_file_raw(&PathBuf::from(opts.input.input))?
 	};
 
-	let val = state.with_tla(val)?;
+	let val = s.with_tla(val)?;
 
 	if let Some(multi) = opts.output.multi {
 		if opts.output.create_output_dirs {
@@ -141,7 +141,7 @@
 			dir.pop();
 			create_dir_all(dir)?;
 		}
-		for (file, data) in state.manifest_multi(val)?.iter() {
+		for (file, data) in s.manifest_multi(val)?.iter() {
 			let mut path = multi.clone();
 			path.push(file as &str);
 			if opts.output.create_output_dirs {
@@ -160,9 +160,9 @@
 			create_dir_all(dir)?;
 		}
 		let mut file = File::create(path)?;
-		writeln!(file, "{}", state.manifest(val)?)?;
+		writeln!(file, "{}", s.manifest(val)?)?;
 	} else {
-		let output = state.manifest(val)?;
+		let output = s.manifest(val)?;
 		if !output.is_empty() {
 			println!("{}", output);
 		}

--- a/crates/jrsonnet-cli/src/ext.rs
+++ b/crates/jrsonnet-cli/src/ext.rs
@@ -1,7 +1,7 @@
 use std::{fs::read_to_string, str::FromStr};
 
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, EvaluationState};
+use jrsonnet_evaluator::{error::Result, State};
 
 use crate::ConfigureState;
 
@@ -100,18 +100,18 @@
 	ext_code_file: Vec<ExtFile>,
 }
 impl ConfigureState for ExtVarOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		for ext in self.ext_str.iter() {
-			state.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
+			s.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
 		}
 		for ext in self.ext_str_file.iter() {
-			state.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
+			s.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
 		}
 		for ext in self.ext_code.iter() {
-			state.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
+			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
 		}
 		for ext in self.ext_code_file.iter() {
-			state.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
+			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
 		}
 		Ok(())
 	}

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -7,13 +7,13 @@
 
 use clap::Parser;
 pub use ext::*;
-use jrsonnet_evaluator::{error::Result, EvaluationState, FileImportResolver};
+use jrsonnet_evaluator::{error::Result, FileImportResolver, State};
 pub use manifest::*;
 pub use tla::*;
 pub use trace::*;
 
 pub trait ConfigureState {
-	fn configure(&self, state: &EvaluationState) -> Result<()>;
+	fn configure(&self, s: &State) -> Result<()>;
 }
 
 #[derive(Parser)]
@@ -50,9 +50,9 @@
 	jpath: Vec<PathBuf>,
 }
 impl ConfigureState for MiscOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		if !self.no_stdlib {
-			state.with_stdlib();
+			s.with_stdlib();
 		}
 
 		let mut library_paths = self.jpath.clone();
@@ -61,9 +61,9 @@
 			library_paths.extend(env::split_paths(path.as_os_str()));
 		}
 
-		state.set_import_resolver(Box::new(FileImportResolver { library_paths }));
+		s.set_import_resolver(Box::new(FileImportResolver { library_paths }));
 
-		state.set_max_stack(self.max_stack);
+		s.set_max_stack(self.max_stack);
 		Ok(())
 	}
 }
@@ -85,12 +85,12 @@
 }
 
 impl ConfigureState for GeneralOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		// Configure trace first, because tla-code/ext-code can throw
-		self.trace.configure(state)?;
-		self.misc.configure(state)?;
-		self.tla.configure(state)?;
-		self.ext.configure(state)?;
+		self.trace.configure(s)?;
+		self.misc.configure(s)?;
+		self.tla.configure(s)?;
+		self.ext.configure(s)?;
 		Ok(())
 	}
 }

--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -1,7 +1,7 @@
 use std::{path::PathBuf, str::FromStr};
 
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, EvaluationState, ManifestFormat};
+use jrsonnet_evaluator::{error::Result, ManifestFormat, State};
 
 use crate::ConfigureState;
 
@@ -49,20 +49,20 @@
 	exp_preserve_order: bool,
 }
 impl ConfigureState for ManifestOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		if self.string {
-			state.set_manifest_format(ManifestFormat::String);
+			s.set_manifest_format(ManifestFormat::String);
 		} else {
 			#[cfg(feature = "exp-preserve-order")]
 			let preserve_order = self.exp_preserve_order;
 			match self.format {
-				ManifestFormatName::String => state.set_manifest_format(ManifestFormat::String),
-				ManifestFormatName::Json => state.set_manifest_format(ManifestFormat::Json {
+				ManifestFormatName::String => s.set_manifest_format(ManifestFormat::String),
+				ManifestFormatName::Json => s.set_manifest_format(ManifestFormat::Json {
 					padding: self.line_padding.unwrap_or(3),
 					#[cfg(feature = "exp-preserve-order")]
 					preserve_order,
 				}),
-				ManifestFormatName::Yaml => state.set_manifest_format(ManifestFormat::Yaml {
+				ManifestFormatName::Yaml => s.set_manifest_format(ManifestFormat::Yaml {
 					padding: self.line_padding.unwrap_or(2),
 					#[cfg(feature = "exp-preserve-order")]
 					preserve_order,
@@ -70,9 +70,7 @@
 			}
 		}
 		if self.yaml_stream {
-			state.set_manifest_format(ManifestFormat::YamlStream(Box::new(
-				state.manifest_format(),
-			)))
+			s.set_manifest_format(ManifestFormat::YamlStream(Box::new(s.manifest_format())))
 		}
 		Ok(())
 	}

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,5 +1,5 @@
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, EvaluationState};
+use jrsonnet_evaluator::{error::Result, State};
 
 use crate::{ConfigureState, ExtFile, ExtStr};
 
@@ -47,18 +47,18 @@
 	tla_code_file: Vec<ExtFile>,
 }
 impl ConfigureState for TLAOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		for tla in self.tla_str.iter() {
-			state.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into());
+			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into());
 		}
 		for tla in self.tla_str_file.iter() {
-			state.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into())
+			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into())
 		}
 		for tla in self.tla_code.iter() {
-			state.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;
+			s.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;
 		}
 		for tla in self.tla_code_file.iter() {
-			state.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;
+			s.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;
 		}
 		Ok(())
 	}

--- a/crates/jrsonnet-cli/src/trace.rs
+++ b/crates/jrsonnet-cli/src/trace.rs
@@ -4,7 +4,7 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	trace::{CompactFormat, ExplainingFormat, PathResolver},
-	EvaluationState,
+	State,
 };
 
 use crate::ConfigureState;
@@ -41,22 +41,22 @@
 	max_trace: usize,
 }
 impl ConfigureState for TraceOpts {
-	fn configure(&self, state: &EvaluationState) -> Result<()> {
+	fn configure(&self, s: &State) -> Result<()> {
 		let resolver = PathResolver::Absolute;
 		match self
 			.trace_format
 			.as_ref()
 			.unwrap_or(&TraceFormatName::Compact)
 		{
-			TraceFormatName::Compact => state.set_trace_format(Box::new(CompactFormat {
+			TraceFormatName::Compact => s.set_trace_format(Box::new(CompactFormat {
 				resolver,
 				padding: 4,
 			})),
 			TraceFormatName::Explaining => {
-				state.set_trace_format(Box::new(ExplainingFormat { resolver }))
+				s.set_trace_format(Box::new(ExplainingFormat { resolver }))
 			}
 		}
-		state.set_max_trace(self.max_trace);
+		s.set_max_trace(self.max_trace);
 		Ok(())
 	}
 }