git.delta.rocks / jrsonnet / refs/commits / 58761866e4bc

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -68,6 +68,15 @@
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
+name = "block-buffer"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
 name = "cc"
 version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -141,6 +150,45 @@
 ]
 
 [[package]]
+name = "cpufeatures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
 name = "getrandom"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -304,6 +352,7 @@
  "serde",
  "serde_json",
  "serde_yaml_with_quirks",
+ "sha2",
  "structdump",
 ]
 
@@ -550,6 +599,17 @@
 ]
 
 [[package]]
+name = "sha2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
 name = "smallvec"
 version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -640,6 +700,12 @@
 ]
 
 [[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
 name = "unicode-ident"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -12,7 +12,7 @@
 };
 
 use jrsonnet_evaluator::{
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	throw, FileImportResolver, ImportResolver,
 };
 use jrsonnet_gcmodule::Trace;

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::box_default)]
+
 #[cfg(feature = "interop")]
 pub mod interop;
 
@@ -20,11 +22,11 @@
 	apply_tla,
 	function::TlaArg,
 	gc::GcHashMap,
+	manifest::{JsonFormat, ManifestFormat, ToStringFormat},
 	stack::set_stack_depth_limit,
-	stdlib::manifest::{JsonFormat, ToStringFormat},
 	tb, throw,
 	trace::{CompactFormat, PathResolver, TraceFormat},
-	FileImportResolver, IStr, ManifestFormat, Result, State, Val,
+	FileImportResolver, IStr, Result, State, Val,
 };
 
 /// WASM stub
@@ -193,7 +195,7 @@
 	let filename = parse_path(CStr::from_ptr(filename));
 	match vm
 		.state
-		.import(&filename)
+		.import(filename)
 		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
 		.and_then(|val| val.manifest(&vm.manifest_format))
 	{
@@ -286,7 +288,7 @@
 	let filename = parse_path(CStr::from_ptr(filename));
 	match vm
 		.state
-		.import(&filename)
+		.import(filename)
 		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
 		.and_then(|val| val_to_multi(val, &vm.manifest_format))
 	{

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -5,7 +5,7 @@
 };
 
 use jrsonnet_evaluator::{
-	error::{Error, LocError},
+	error::{Error, ErrorKind},
 	function::builtin::{NativeCallback, NativeCallbackHandler},
 	tb,
 	typed::Typed,
@@ -38,7 +38,7 @@
 	cb: JsonnetNativeCallback,
 }
 impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
-	fn call(&self, args: &[Val]) -> Result<Val, LocError> {
+	fn call(&self, args: &[Val]) -> Result<Val, Error> {
 		let mut n_args = Vec::new();
 		for a in args {
 			n_args.push(Some(Box::new(a.clone())));
@@ -57,7 +57,7 @@
 			Ok(v)
 		} else {
 			let e = IStr::from_untyped(v).expect("error msg should be a string");
-			Err(Error::RuntimeError(e).into())
+			Err(ErrorKind::RuntimeError(e).into())
 		}
 	}
 }

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -6,7 +6,11 @@
 use clap::{CommandFactory, Parser};
 use clap_complete::Shell;
 use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts, TraceOpts};
-use jrsonnet_evaluator::{apply_tla, error::LocError, throw, ResultExt, State, Val};
+use jrsonnet_evaluator::{
+	apply_tla,
+	error::{Error as JrError, ErrorKind},
+	throw, ResultExt, State, Val,
+};
 
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
@@ -96,7 +100,7 @@
 enum Error {
 	// Handled differently
 	#[error("evaluation error")]
-	Evaluation(LocError),
+	Evaluation(JrError),
 	#[error("io error")]
 	Io(#[from] std::io::Error),
 	#[error("input is not utf8 encoded")]
@@ -104,14 +108,14 @@
 	#[error("missing input argument")]
 	MissingInputArgument,
 }
-impl From<LocError> for Error {
-	fn from(e: LocError) -> Self {
+impl From<JrError> for Error {
+	fn from(e: JrError) -> Self {
 		Self::Evaluation(e)
 	}
 }
-impl From<jrsonnet_evaluator::error::Error> for Error {
-	fn from(e: jrsonnet_evaluator::error::Error) -> Self {
-		Self::from(LocError::from(e))
+impl From<ErrorKind> for Error {
+	fn from(e: ErrorKind) -> Self {
+		Self::from(JrError::from(e))
 	}
 }
 

--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -3,9 +3,10 @@
 use clap::{Parser, ValueEnum};
 use jrsonnet_evaluator::{
 	error::Result,
-	stdlib::manifest::{JsonFormat, StringFormat, ToStringFormat, YamlFormat, YamlStreamFormat},
-	ManifestFormat, State,
+	manifest::{JsonFormat, ManifestFormat, StringFormat, ToStringFormat, YamlStreamFormat},
+	State,
 };
+use jrsonnet_stdlib::YamlFormat;
 
 use crate::ConfigureState;
 

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,6 +1,6 @@
 use clap::Parser;
 use jrsonnet_evaluator::{
-	error::{Error, Result},
+	error::{ErrorKind, Result},
 	function::TlaArg,
 	gc::GcHashMap,
 	IStr, State,
@@ -51,15 +51,15 @@
 		{
 			let source = Source::new_virtual(format!("<top-level-arg:{name}>").into(), code.into());
 			out.insert(
-				(&name as &str).into(),
+				(name as &str).into(),
 				TlaArg::Code(
 					jrsonnet_parser::parse(
-						&code,
+						code,
 						&ParserSettings {
 							source: source.clone(),
 						},
 					)
-					.map_err(|e| Error::ImportSyntaxError {
+					.map_err(|e| ErrorKind::ImportSyntaxError {
 						path: source,
 						error: Box::new(e),
 					})?,

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -4,8 +4,8 @@
 use jrsonnet_interner::IStr;
 
 use crate::{
-	error::Error::*, gc::GcHashMap, map::LayeredHashMap, ObjValue, Pending, Result, State, Thunk,
-	Val,
+	error::ErrorKind::*, gc::GcHashMap, map::LayeredHashMap, ObjValue, Pending, Result, State,
+	Thunk, Val,
 };
 
 #[derive(Trace)]

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -74,7 +74,7 @@
 #[allow(missing_docs)]
 #[derive(Error, Debug, Clone, Trace)]
 #[non_exhaustive]
-pub enum Error {
+pub enum ErrorKind {
 	#[error("intrinsic not found: {0}")]
 	IntrinsicNotFound(IStr),
 
@@ -211,14 +211,14 @@
 }
 
 #[cfg(feature = "anyhow-error")]
-impl From<anyhow::Error> for LocError {
+impl From<anyhow::Error> for Error {
 	fn from(e: anyhow::Error) -> Self {
-		Self::new(Error::Other(Rc::new(e)))
+		Self::new(ErrorKind::Other(Rc::new(e)))
 	}
 }
 
-impl From<Error> for LocError {
-	fn from(e: Error) -> Self {
+impl From<ErrorKind> for Error {
+	fn from(e: ErrorKind) -> Self {
 		Self::new(e)
 	}
 }
@@ -236,16 +236,16 @@
 pub struct StackTrace(pub Vec<StackTraceElement>);
 
 #[derive(Clone, Trace)]
-pub struct LocError(Box<(Error, StackTrace)>);
-impl LocError {
-	pub fn new(e: Error) -> Self {
+pub struct Error(Box<(ErrorKind, StackTrace)>);
+impl Error {
+	pub fn new(e: ErrorKind) -> Self {
 		Self(Box::new((e, StackTrace(vec![]))))
 	}
 
-	pub const fn error(&self) -> &Error {
+	pub const fn error(&self) -> &ErrorKind {
 		&(self.0).0
 	}
-	pub fn error_mut(&mut self) -> &mut Error {
+	pub fn error_mut(&mut self) -> &mut ErrorKind {
 		&mut (self.0).0
 	}
 	pub const fn trace(&self) -> &StackTrace {
@@ -255,7 +255,7 @@
 		&mut (self.0).1
 	}
 }
-impl Display for LocError {
+impl Display for Error {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		writeln!(f, "{}", self.0 .0)?;
 		for el in &self.0 .1 .0 {
@@ -269,7 +269,7 @@
 		Ok(())
 	}
 }
-impl Debug for LocError {
+impl Debug for Error {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.debug_tuple("LocError").field(&self.0).finish()
 	}
@@ -294,7 +294,7 @@
 	}
 }
 
-pub type Result<V, E = LocError> = std::result::Result<V, E>;
+pub type Result<V, E = Error> = std::result::Result<V, E>;
 pub trait ResultExt: Sized {
 	#[must_use]
 	fn with_description<O: Into<String>>(self, msg: impl FnOnce() -> O) -> Self;
@@ -314,7 +314,7 @@
 		self.with_description_src(src, || msg)
 	}
 }
-impl<T> ResultExt for Result<T, LocError> {
+impl<T> ResultExt for Result<T, Error> {
 	fn with_description<O: Into<String>>(mut self, msg: impl FnOnce() -> O) -> Self {
 		if let Err(e) = &mut self {
 			let trace = e.trace_mut();
@@ -348,9 +348,9 @@
 		return Err($w$(::$i)*$(($($tt)*))?.into())
 	};
 	($l:literal) => {
-		return Err($crate::error::Error::RuntimeError($l.into()).into())
+		return Err($crate::error::ErrorKind::RuntimeError($l.into()).into())
 	};
 	($l:literal, $($tt:tt)*) => {
-		return Err($crate::error::Error::RuntimeError(format!($l, $($tt)*).into()).into())
+		return Err($crate::error::ErrorKind::RuntimeError(format!($l, $($tt)*).into()).into())
 	};
 }

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -3,7 +3,7 @@
 use jrsonnet_parser::{BindSpec, Destruct, LocExpr, ParamsDesc};
 
 use crate::{
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	evaluate, evaluate_method, evaluate_named,
 	gc::GcHashMap,
 	tb, throw,

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -11,14 +11,14 @@
 use self::destructure::destruct;
 use crate::{
 	destructure::evaluate_dest,
-	error::Error::*,
+	error::ErrorKind::*,
 	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},
 	function::{CallLocation, FuncDesc, FuncVal},
 	tb, throw,
 	typed::Typed,
 	val::{ArrValue, CachedUnbound, IndexableVal, Thunk, ThunkValue},
-	Context, GcHashMap, LocError, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,
-	ResultExt, State, Unbound, Val,
+	Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, State,
+	Unbound, Val,
 };
 pub mod destructure;
 pub mod operator;
@@ -165,7 +165,7 @@
 	uctx: B,
 	field: &FieldMember,
 ) -> Result<()> {
-	let name = evaluate_field_name(ctx.clone(), &field.name)?;
+	let name = evaluate_field_name(ctx, &field.name)?;
 	let Some(name) = name else {
 		return Ok(());
 	};
@@ -187,11 +187,7 @@
 			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
 				type Bound = Val;
 				fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {
-					Ok(evaluate_named(
-						self.uctx.bind(sup, this)?,
-						&self.value,
-						self.name.clone(),
-					)?)
+					evaluate_named(self.uctx.bind(sup, this)?, &self.value, self.name.clone())
 				}
 			}
 
@@ -201,9 +197,9 @@
 				.with_visibility(*visibility)
 				.with_location(value.1.clone())
 				.bindable(tb!(UnboundValue {
-					uctx: uctx.clone(),
+					uctx,
 					value: value.clone(),
-					name: name.clone()
+					name,
 				}))?;
 		}
 		FieldMember {
@@ -236,10 +232,10 @@
 				.with_visibility(*visibility)
 				.with_location(value.1.clone())
 				.bindable(tb!(UnboundMethod {
-					uctx: uctx.clone(),
+					uctx,
 					value: value.clone(),
 					params: params.clone(),
-					name: name.clone()
+					name,
 				}))?;
 		}
 	}
@@ -267,7 +263,7 @@
 	for member in members.iter() {
 		match member {
 			Member::Field(field) => {
-				evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), &field)?
+				evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;
 			}
 			Member::AssertStmt(stmt) => {
 				#[derive(Trace)]

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -3,7 +3,7 @@
 use jrsonnet_parser::{BinaryOpType, LocExpr, UnaryOpType};
 
 use crate::{
-	error::Error::*, evaluate, stdlib::std_format, throw, typed::Typed, val::equals, Context,
+	error::ErrorKind::*, evaluate, stdlib::std_format, throw, typed::Typed, val::equals, Context,
 	Result, Val,
 };
 

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -180,8 +180,8 @@
 	}
 }
 
-impl<A: ArgLike, S> sealed::Named for HashMap<IStr, A, S> {}
-impl<A: ArgLike, S> ArgsLike for HashMap<IStr, A, S> {
+impl<V: ArgLike, S> sealed::Named for HashMap<IStr, V, S> {}
+impl<V: ArgLike, S> ArgsLike for HashMap<IStr, V, S> {
 	fn unnamed_len(&self) -> usize {
 		0
 	}
@@ -213,7 +213,7 @@
 		}
 	}
 }
-impl<A, S> OptionalContext for HashMap<IStr, A, S> where A: ArgLike + OptionalContext {}
+impl<V, S> OptionalContext for HashMap<IStr, V, S> where V: ArgLike + OptionalContext {}
 
 impl<A: ArgLike> ArgsLike for GcHashMap<IStr, A> {
 	fn unnamed_len(&self) -> usize {
@@ -239,7 +239,7 @@
 	}
 
 	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
-		self.0.named_names(handler)
+		self.0.named_names(handler);
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -7,7 +7,7 @@
 use super::{arglike::ArgsLike, builtin::BuiltinParam};
 use crate::{
 	destructure::destruct,
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	evaluate_named,
 	gc::GcHashMap,
 	tb, throw,

--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -12,10 +12,7 @@
 use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
 
 use crate::{
-	error::{
-		Error::{self, *},
-		Result,
-	},
+	error::{ErrorKind::*, Result},
 	throw,
 };
 
@@ -94,7 +91,7 @@
 		} else if let Some(d) = from.downcast_ref::<SourceDirectory>() {
 			d.path().to_owned()
 		} else if from.is_default() {
-			current_dir().map_err(|e| Error::ImportIo(e.to_string()))?
+			current_dir().map_err(|e| ImportIo(e.to_string()))?
 		} else {
 			unreachable!("resolver can't return this path")
 		};
@@ -122,7 +119,7 @@
 			Err(e) if e.kind() == ErrorKind::NotFound => {
 				throw!(AbsoluteImportFileNotFound(path.to_owned()))
 			}
-			Err(e) => throw!(Error::ImportIo(e.to_string())),
+			Err(e) => throw!(ImportIo(e.to_string())),
 		};
 		if meta.is_file() {
 			Ok(SourcePath::new(SourceFile::new(
@@ -141,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!(Error::ImportIsADirectory(id.clone()))
+			throw!(ImportIsADirectory(id.clone()))
 		} else {
 			unreachable!("other types are not supported in resolve");
 		};

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -11,7 +11,7 @@
 use rustc_hash::FxHashMap;
 
 use crate::{
-	error::{Error::*, LocError},
+	error::{Error, ErrorKind::*},
 	function::CallLocation,
 	gc::{GcHashMap, GcHashSet, TraceBox},
 	operator::evaluate_add_op,
@@ -115,7 +115,7 @@
 	Cached(Val),
 	NotFound,
 	Pending,
-	Errored(LocError),
+	Errored(Error),
 }
 
 #[allow(clippy::module_name_repetitions)]

--- a/crates/jrsonnet-evaluator/src/stack.rs
+++ b/crates/jrsonnet-evaluator/src/stack.rs
@@ -1,6 +1,6 @@
 use std::{cell::Cell, marker::PhantomData};
 
-use crate::error::{Error, LocError};
+use crate::error::{Error, ErrorKind};
 
 struct StackLimit {
 	max_stack_size: Cell<usize>,
@@ -22,14 +22,14 @@
 }
 
 pub struct StackOverflowError;
-impl From<StackOverflowError> for Error {
+impl From<StackOverflowError> for ErrorKind {
 	fn from(_: StackOverflowError) -> Self {
-		Error::StackOverflow
+		ErrorKind::StackOverflow
 	}
 }
-impl From<StackOverflowError> for LocError {
+impl From<StackOverflowError> for Error {
 	fn from(_: StackOverflowError) -> Self {
-		Error::StackOverflow.into()
+		ErrorKind::StackOverflow.into()
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -6,7 +6,7 @@
 use jrsonnet_types::ValType;
 use thiserror::Error;
 
-use crate::{error::Error::*, throw, typed::Typed, LocError, ObjValue, Result, Val};
+use crate::{error::ErrorKind::*, throw, typed::Typed, Error, ObjValue, Result, Val};
 
 #[derive(Debug, Clone, Error, Trace)]
 pub enum FormatError {
@@ -26,7 +26,7 @@
 	NoSuchFormatField(IStr),
 }
 
-impl From<FormatError> for LocError {
+impl From<FormatError> for Error {
 	fn from(e: FormatError) -> Self {
 		Self::new(Format(e))
 	}

--- a/crates/jrsonnet-evaluator/src/stdlib/mod.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/mod.rs
@@ -7,7 +7,6 @@
 use crate::{error::Result, function::CallLocation, State, Val};
 
 pub mod format;
-pub mod manifest;
 
 pub fn std_format(str: IStr, vals: Val) -> Result<String> {
 	State::push(

--- a/crates/jrsonnet-evaluator/src/trace/mod.rs
+++ b/crates/jrsonnet-evaluator/src/trace/mod.rs
@@ -6,7 +6,7 @@
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_parser::{CodeLocation, Source};
 
-use crate::{error::Error, LocError};
+use crate::{error::ErrorKind, Error};
 
 /// The way paths should be displayed
 #[derive(Clone, Trace)]
@@ -51,9 +51,9 @@
 	fn write_trace(
 		&self,
 		out: &mut dyn std::fmt::Write,
-		error: &LocError,
+		error: &Error,
 	) -> Result<(), std::fmt::Error>;
-	fn format(&self, error: &LocError) -> Result<String, std::fmt::Error> {
+	fn format(&self, error: &Error) -> Result<String, std::fmt::Error> {
 		let mut out = String::new();
 		self.write_trace(&mut out, error)?;
 		Ok(out)
@@ -107,10 +107,10 @@
 	fn write_trace(
 		&self,
 		out: &mut dyn std::fmt::Write,
-		error: &LocError,
+		error: &Error,
 	) -> Result<(), std::fmt::Error> {
 		write!(out, "{}", error.error())?;
-		if let Error::ImportSyntaxError { path, error } = error.error() {
+		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {
 			use std::fmt::Write;
 
 			writeln!(out)?;
@@ -204,7 +204,7 @@
 	fn write_trace(
 		&self,
 		out: &mut dyn std::fmt::Write,
-		error: &LocError,
+		error: &Error,
 	) -> Result<(), std::fmt::Error> {
 		write!(out, "{}", error.error())?;
 		for item in &error.trace().0 {
@@ -250,10 +250,10 @@
 	fn write_trace(
 		&self,
 		out: &mut dyn std::fmt::Write,
-		error: &LocError,
+		error: &Error,
 	) -> Result<(), std::fmt::Error> {
 		write!(out, "{}", error.error())?;
-		if let Error::ImportSyntaxError { path, error } = error.error() {
+		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {
 			writeln!(out)?;
 			let offset = error.location.offset;
 			let location = path

--- a/crates/jrsonnet-evaluator/src/typed/mod.rs
+++ b/crates/jrsonnet-evaluator/src/typed/mod.rs
@@ -7,7 +7,7 @@
 use thiserror::Error;
 
 use crate::{
-	error::{Error, LocError, Result},
+	error::{Error, ErrorKind, Result},
 	State, Val,
 };
 
@@ -26,9 +26,9 @@
 	)]
 	BoundsFailed(f64, Option<f64>, Option<f64>),
 }
-impl From<TypeError> for LocError {
+impl From<TypeError> for Error {
 	fn from(e: TypeError) -> Self {
-		Error::TypeError(e.into()).into()
+		ErrorKind::TypeError(e.into()).into()
 	}
 }
 
@@ -39,9 +39,9 @@
 		Self(Box::new(e), ValuePathStack(Vec::new()))
 	}
 }
-impl From<TypeLocError> for LocError {
+impl From<TypeLocError> for Error {
 	fn from(e: TypeLocError) -> Self {
-		Error::TypeError(e).into()
+		ErrorKind::TypeError(e).into()
 	}
 }
 impl Display for TypeLocError {
@@ -92,7 +92,7 @@
 	State::push_description(error_reason, || match item() {
 		Ok(_) => Ok(()),
 		Err(mut e) => {
-			if let Error::TypeError(e) = &mut e.error_mut() {
+			if let ErrorKind::TypeError(e) = &mut e.error_mut() {
 				(e.1).0.push(path());
 			}
 			Err(e)
@@ -218,7 +218,7 @@
 							return Ok(());
 						}
 						Err(e) => match e.error() {
-							Error::TypeError(e) => errors.push(e.clone()),
+							ErrorKind::TypeError(e) => errors.push(e.clone()),
 							_ => return Err(e),
 						},
 					}
@@ -233,7 +233,7 @@
 							return Ok(());
 						}
 						Err(e) => match e.error() {
-							Error::TypeError(e) => errors.push(e.clone()),
+							ErrorKind::TypeError(e) => errors.push(e.clone()),
 							_ => return Err(e),
 						},
 					}

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -5,9 +5,10 @@
 use jrsonnet_types::ValType;
 
 use crate::{
-	error::{Error::*, LocError},
+	error::{Error, ErrorKind::*},
 	function::FuncVal,
 	gc::{GcHashMap, TraceBox},
+	manifest::{ManifestFormat, ToStringFormat},
 	throw,
 	typed::BoundedUsize,
 	ObjValue, Result, Unbound, WeakObjValue,
@@ -21,7 +22,7 @@
 #[derive(Trace)]
 enum ThunkInner<T: Trace> {
 	Computed(T),
-	Errored(LocError),
+	Errored(Error),
 	Waiting(TraceBox<dyn ThunkValue<Output = T>>),
 	Pending,
 }
@@ -116,33 +117,6 @@
 impl<T: Trace> PartialEq for Thunk<T> {
 	fn eq(&self, other: &Self) -> bool {
 		Cc::ptr_eq(&self.0, &other.0)
-	}
-}
-
-pub trait ManifestFormat {
-	fn manifest_buf(&self, val: Val, buf: &mut String) -> Result<()>;
-	fn manifest(&self, val: Val) -> Result<String> {
-		let mut out = String::new();
-		self.manifest_buf(val, &mut out)?;
-		Ok(out)
-	}
-}
-impl<T> ManifestFormat for Box<T>
-where
-	T: ManifestFormat + ?Sized,
-{
-	fn manifest_buf(&self, val: Val, buf: &mut String) -> Result<()> {
-		let inner = &**self;
-		inner.manifest_buf(val, buf)
-	}
-}
-impl<T> ManifestFormat for &'_ T
-where
-	T: ManifestFormat + ?Sized,
-{
-	fn manifest_buf(&self, val: Val, buf: &mut String) -> Result<()> {
-		let inner = &**self;
-		inner.manifest_buf(val, buf)
 	}
 }
 
@@ -649,9 +623,7 @@
 			Self::Bool(false) => "false".into(),
 			Self::Null => "null".into(),
 			Self::Str(s) => s.clone(),
-			_ => self
-				.manifest(crate::stdlib::manifest::ToStringFormat)
-				.map(IStr::from)?,
+			_ => self.manifest(ToStringFormat).map(IStr::from)?,
 		})
 	}