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

difftreelog

style fix clippy warnings

Yaroslav Bolyukin2022-11-12parent: #9a50551.patch.diff
in: master

35 files changed

modifiedCargo.lockdiffbeforeafterboth
--- 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"
modifiedbindings/jsonnet/src/import.rsdiffbeforeafterboth
--- 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;
modifiedbindings/jsonnet/src/lib.rsdiffbeforeafterboth
--- 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))
 	{
modifiedbindings/jsonnet/src/native.rsdiffbeforeafterboth
--- 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())
 		}
 	}
 }
modifiedcmds/jrsonnet/src/main.rsdiffbeforeafterboth
before · cmds/jrsonnet/src/main.rs
1use std::{2	fs::{create_dir_all, File},3	io::{Read, Write},4};56use clap::{CommandFactory, Parser};7use clap_complete::Shell;8use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts, TraceOpts};9use jrsonnet_evaluator::{apply_tla, error::LocError, throw, ResultExt, State, Val};1011#[cfg(feature = "mimalloc")]12#[global_allocator]13static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;1415#[derive(Parser)]16enum SubOpts {17	/// Generate completions for specified shell18	Generate {19		/// Target shell name20		shell: Shell,21	},22}2324#[derive(Parser)]25#[clap(next_help_heading = "DEBUG")]26struct DebugOpts {27	/// Required OS stack size.28	/// This shouldn't be changed unless jrsonnet is failing with stack overflow error.29	#[clap(long, name = "size")]30	pub os_stack: Option<usize>,31}3233#[derive(Parser)]34#[clap(next_help_heading = "INPUT")]35struct InputOpts {36	/// Treat input as code, evaluate them instead of reading file37	#[clap(long, short = 'e')]38	pub exec: bool,3940	/// Path to the file to be compiled if `--evaluate` is unset, otherwise code itself41	pub input: Option<String>,42}4344#[derive(Parser)]45#[clap(args_conflicts_with_subcommands = true, disable_version_flag = true)]46struct Opts {47	#[clap(subcommand)]48	sub: Option<SubOpts>,4950	#[clap(flatten)]51	input: InputOpts,52	#[clap(flatten)]53	general: GeneralOpts,5455	#[clap(flatten)]56	trace: TraceOpts,57	#[clap(flatten)]58	manifest: ManifestOpts,59	#[clap(flatten)]60	output: OutputOpts,61	#[clap(flatten)]62	debug: DebugOpts,63}6465fn main() {66	let opts: Opts = Opts::parse();6768	if let Some(sub) = opts.sub {69		match sub {70			SubOpts::Generate { shell } => {71				use clap_complete::generate;72				let app = &mut Opts::command();73				let buf = &mut std::io::stdout();74				generate(shell, app, "jrsonnet", buf);75				std::process::exit(0)76			}77		}78	}7980	let success = if let Some(size) = opts.debug.os_stack {81		std::thread::Builder::new()82			.stack_size(size * 1024 * 1024)83			.spawn(|| main_catch(opts))84			.expect("new thread spawned")85			.join()86			.expect("thread finished successfully")87	} else {88		main_catch(opts)89	};90	if !success {91		std::process::exit(1);92	}93}9495#[derive(thiserror::Error, Debug)]96enum Error {97	// Handled differently98	#[error("evaluation error")]99	Evaluation(LocError),100	#[error("io error")]101	Io(#[from] std::io::Error),102	#[error("input is not utf8 encoded")]103	Utf8(#[from] std::str::Utf8Error),104	#[error("missing input argument")]105	MissingInputArgument,106}107impl From<LocError> for Error {108	fn from(e: LocError) -> Self {109		Self::Evaluation(e)110	}111}112impl From<jrsonnet_evaluator::error::Error> for Error {113	fn from(e: jrsonnet_evaluator::error::Error) -> Self {114		Self::from(LocError::from(e))115	}116}117118fn main_catch(opts: Opts) -> bool {119	let s = State::default();120	let trace = opts121		.trace122		.configure(&s)123		.expect("this configurator doesn't fail");124	if let Err(e) = main_real(&s, opts) {125		if let Error::Evaluation(e) = e {126			let mut out = String::new();127			trace.write_trace(&mut out, &e).expect("format error");128			eprintln!("{out}")129		} else {130			eprintln!("{}", e);131		}132		return false;133	}134	true135}136137fn main_real(s: &State, opts: Opts) -> Result<(), Error> {138	let (_stack_guard, tla, _gc_guard) = opts.general.configure(s)?;139	let manifest_format = opts.manifest.configure(s)?;140141	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;142	let val = if opts.input.exec {143		s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?144	} else if input == "-" {145		let mut input = Vec::new();146		std::io::stdin().read_to_end(&mut input)?;147		let input_str = std::str::from_utf8(&input)?;148		s.evaluate_snippet("<stdin>".to_owned(), input_str)?149	} else {150		s.import(&input)?151	};152153	let val = apply_tla(s.clone(), &tla, val)?;154155	if let Some(multi) = opts.output.multi {156		if opts.output.create_output_dirs {157			let mut dir = multi.clone();158			dir.pop();159			create_dir_all(dir)?;160		}161		let Val::Obj(obj) = val else {162			throw!("value should be object for --multi manifest, got {}", val.value_type())163		};164		for (field, data) in obj.iter(165			#[cfg(feature = "exp-preserve-order")]166			opts.manifest.preserve_order,167		) {168			let data = data.with_description(|| format!("getting field {field} for manifest"))?;169170			let mut path = multi.clone();171			path.push(&field as &str);172			if opts.output.create_output_dirs {173				let mut dir = path.clone();174				dir.pop();175				create_dir_all(dir)?;176			}177			println!("{}", path.to_str().expect("path"));178			let mut file = File::create(path)?;179			writeln!(180				file,181				"{}",182				data.manifest(&manifest_format)183					.with_description(|| format!("manifesting {field}"))?184			)?;185		}186	} else if let Some(path) = opts.output.output_file {187		if opts.output.create_output_dirs {188			let mut dir = path.clone();189			dir.pop();190			create_dir_all(dir)?;191		}192		let mut file = File::create(path)?;193		writeln!(file, "{}", val.manifest(manifest_format)?)?;194	} else {195		let output = val.manifest(manifest_format)?;196		if !output.is_empty() {197			println!("{}", output);198		}199	}200201	Ok(())202}
after · cmds/jrsonnet/src/main.rs
1use std::{2	fs::{create_dir_all, File},3	io::{Read, Write},4};56use clap::{CommandFactory, Parser};7use clap_complete::Shell;8use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts, TraceOpts};9use jrsonnet_evaluator::{10	apply_tla,11	error::{Error as JrError, ErrorKind},12	throw, ResultExt, State, Val,13};1415#[cfg(feature = "mimalloc")]16#[global_allocator]17static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;1819#[derive(Parser)]20enum SubOpts {21	/// Generate completions for specified shell22	Generate {23		/// Target shell name24		shell: Shell,25	},26}2728#[derive(Parser)]29#[clap(next_help_heading = "DEBUG")]30struct DebugOpts {31	/// Required OS stack size.32	/// This shouldn't be changed unless jrsonnet is failing with stack overflow error.33	#[clap(long, name = "size")]34	pub os_stack: Option<usize>,35}3637#[derive(Parser)]38#[clap(next_help_heading = "INPUT")]39struct InputOpts {40	/// Treat input as code, evaluate them instead of reading file41	#[clap(long, short = 'e')]42	pub exec: bool,4344	/// Path to the file to be compiled if `--evaluate` is unset, otherwise code itself45	pub input: Option<String>,46}4748#[derive(Parser)]49#[clap(args_conflicts_with_subcommands = true, disable_version_flag = true)]50struct Opts {51	#[clap(subcommand)]52	sub: Option<SubOpts>,5354	#[clap(flatten)]55	input: InputOpts,56	#[clap(flatten)]57	general: GeneralOpts,5859	#[clap(flatten)]60	trace: TraceOpts,61	#[clap(flatten)]62	manifest: ManifestOpts,63	#[clap(flatten)]64	output: OutputOpts,65	#[clap(flatten)]66	debug: DebugOpts,67}6869fn main() {70	let opts: Opts = Opts::parse();7172	if let Some(sub) = opts.sub {73		match sub {74			SubOpts::Generate { shell } => {75				use clap_complete::generate;76				let app = &mut Opts::command();77				let buf = &mut std::io::stdout();78				generate(shell, app, "jrsonnet", buf);79				std::process::exit(0)80			}81		}82	}8384	let success = if let Some(size) = opts.debug.os_stack {85		std::thread::Builder::new()86			.stack_size(size * 1024 * 1024)87			.spawn(|| main_catch(opts))88			.expect("new thread spawned")89			.join()90			.expect("thread finished successfully")91	} else {92		main_catch(opts)93	};94	if !success {95		std::process::exit(1);96	}97}9899#[derive(thiserror::Error, Debug)]100enum Error {101	// Handled differently102	#[error("evaluation error")]103	Evaluation(JrError),104	#[error("io error")]105	Io(#[from] std::io::Error),106	#[error("input is not utf8 encoded")]107	Utf8(#[from] std::str::Utf8Error),108	#[error("missing input argument")]109	MissingInputArgument,110}111impl From<JrError> for Error {112	fn from(e: JrError) -> Self {113		Self::Evaluation(e)114	}115}116impl From<ErrorKind> for Error {117	fn from(e: ErrorKind) -> Self {118		Self::from(JrError::from(e))119	}120}121122fn main_catch(opts: Opts) -> bool {123	let s = State::default();124	let trace = opts125		.trace126		.configure(&s)127		.expect("this configurator doesn't fail");128	if let Err(e) = main_real(&s, opts) {129		if let Error::Evaluation(e) = e {130			let mut out = String::new();131			trace.write_trace(&mut out, &e).expect("format error");132			eprintln!("{out}")133		} else {134			eprintln!("{}", e);135		}136		return false;137	}138	true139}140141fn main_real(s: &State, opts: Opts) -> Result<(), Error> {142	let (_stack_guard, tla, _gc_guard) = opts.general.configure(s)?;143	let manifest_format = opts.manifest.configure(s)?;144145	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;146	let val = if opts.input.exec {147		s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?148	} else if input == "-" {149		let mut input = Vec::new();150		std::io::stdin().read_to_end(&mut input)?;151		let input_str = std::str::from_utf8(&input)?;152		s.evaluate_snippet("<stdin>".to_owned(), input_str)?153	} else {154		s.import(&input)?155	};156157	let val = apply_tla(s.clone(), &tla, val)?;158159	if let Some(multi) = opts.output.multi {160		if opts.output.create_output_dirs {161			let mut dir = multi.clone();162			dir.pop();163			create_dir_all(dir)?;164		}165		let Val::Obj(obj) = val else {166			throw!("value should be object for --multi manifest, got {}", val.value_type())167		};168		for (field, data) in obj.iter(169			#[cfg(feature = "exp-preserve-order")]170			opts.manifest.preserve_order,171		) {172			let data = data.with_description(|| format!("getting field {field} for manifest"))?;173174			let mut path = multi.clone();175			path.push(&field as &str);176			if opts.output.create_output_dirs {177				let mut dir = path.clone();178				dir.pop();179				create_dir_all(dir)?;180			}181			println!("{}", path.to_str().expect("path"));182			let mut file = File::create(path)?;183			writeln!(184				file,185				"{}",186				data.manifest(&manifest_format)187					.with_description(|| format!("manifesting {field}"))?188			)?;189		}190	} else if let Some(path) = opts.output.output_file {191		if opts.output.create_output_dirs {192			let mut dir = path.clone();193			dir.pop();194			create_dir_all(dir)?;195		}196		let mut file = File::create(path)?;197		writeln!(file, "{}", val.manifest(manifest_format)?)?;198	} else {199		let output = val.manifest(manifest_format)?;200		if !output.is_empty() {201			println!("{}", output);202		}203	}204205	Ok(())206}
modifiedcrates/jrsonnet-cli/src/manifest.rsdiffbeforeafterboth
--- 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;
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 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),
 					})?,
modifiedcrates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth
--- 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)]
modifiedcrates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth
--- 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())
 	};
 }
modifiedcrates/jrsonnet-evaluator/src/evaluate/destructure.rsdiffbeforeafterboth
--- 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,
modifiedcrates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth
--- 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)]
modifiedcrates/jrsonnet-evaluator/src/evaluate/operator.rsdiffbeforeafterboth
--- 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,
 };
modifiedcrates/jrsonnet-evaluator/src/function/arglike.rsdiffbeforeafterboth
--- 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);
 	}
 }
modifiedcrates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth
--- 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,
modifiedcrates/jrsonnet-evaluator/src/import.rsdiffbeforeafterboth
--- 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");
 		};
modifiedcrates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -51,6 +51,7 @@
 pub mod gc;
 mod import;
 mod integrations;
+pub mod manifest;
 mod map;
 mod obj;
 pub mod stack;
@@ -69,7 +70,7 @@
 
 pub use ctx::*;
 pub use dynamic::*;
-pub use error::{Error::*, LocError, Result, ResultExt};
+pub use error::{Error, ErrorKind::*, Result, ResultExt};
 pub use evaluate::*;
 use function::CallLocation;
 use gc::{GcHashMap, TraceBox};
@@ -82,7 +83,7 @@
 pub use obj::*;
 use stack::check_depth;
 pub use tla::apply_tla;
-pub use val::{ManifestFormat, Thunk, Val};
+pub use val::{Thunk, Val};
 
 /// Thunk without bound `super`/`this`
 /// object inheritance may be overriden multiple times, and will be fixed only on field read
modifiedcrates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth
--- 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)]
modifiedcrates/jrsonnet-evaluator/src/stack.rsdiffbeforeafterboth
--- 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()
 	}
 }
modifiedcrates/jrsonnet-evaluator/src/stdlib/format.rsdiffbeforeafterboth
--- 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))
 	}
modifiedcrates/jrsonnet-evaluator/src/stdlib/mod.rsdiffbeforeafterboth
--- 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(
modifiedcrates/jrsonnet-evaluator/src/trace/mod.rsdiffbeforeafterboth
--- 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
modifiedcrates/jrsonnet-evaluator/src/typed/mod.rsdiffbeforeafterboth
--- 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),
 						},
 					}
modifiedcrates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth
--- 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)?,
 		})
 	}
modifiedcrates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -540,7 +540,7 @@
 			}
 		} else {
 			quote! {
-				<#ty>::from_untyped(obj.get(#name.into())?.ok_or_else(|| Error::NoSuchField(#name.into(), vec![]))?)?
+				<#ty>::from_untyped(obj.get(#name.into())?.ok_or_else(|| ErrorKind::NoSuchField(#name.into(), vec![]))?)?
 			}
 		};
 
@@ -638,19 +638,19 @@
 			use ::jrsonnet_evaluator::{
 				typed::{ComplexValType, Typed, TypedObj, CheckType},
 				Val, State,
-				error::{LocError, Error, Result},
+				error::{ErrorKind, Result as JrResult},
 				ObjValueBuilder, ObjValue,
 			};
 
 			#typed
 
 			impl TypedObj for #ident {
-				fn serialize(self, out: &mut ObjValueBuilder) -> Result<(), LocError> {
+				fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {
 					#(#fields_serialize)*
 
 					Ok(())
 				}
-				fn parse(obj: &ObjValue) -> Result<Self, LocError> {
+				fn parse(obj: &ObjValue) -> JrResult<Self> {
 					Ok(Self {
 						#(#fields_parse)*
 					})
modifiedcrates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -450,15 +450,23 @@
 	fn imports() {
 		assert_eq!(
 			parse!("import \"hello\""),
-			el!(Expr::Import("hello".into()), 0, 14),
+			el!(Expr::Import(el!(Expr::Str("hello".into()), 7, 14)), 0, 14),
 		);
 		assert_eq!(
 			parse!("importstr \"garnish.txt\""),
-			el!(Expr::ImportStr("garnish.txt".into()), 0, 23)
+			el!(
+				Expr::ImportStr(el!(Expr::Str("garnish.txt".into()), 10, 23)),
+				0,
+				23
+			)
 		);
 		assert_eq!(
 			parse!("importbin \"garnish.bin\""),
-			el!(Expr::ImportBin("garnish.bin".into()), 0, 23)
+			el!(
+				Expr::ImportBin(el!(Expr::Str("garnish.bin".into()), 10, 23)),
+				0,
+				23
+			)
 		);
 	}
modifiedcrates/jrsonnet-stdlib/Cargo.tomldiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/Cargo.toml
+++ b/crates/jrsonnet-stdlib/Cargo.toml
@@ -7,7 +7,7 @@
 edition = "2021"
 
 [features]
-default = ["codegenerated-stdlib"]
+default = ["codegenerated-stdlib", "exp-more-hashes"]
 # Speed-up initialization by generating code for parsed stdlib, instead
 # of invoking parser for it
 codegenerated-stdlib = ["jrsonnet-parser/structdump"]
@@ -15,6 +15,7 @@
 legacy-this-file = []
 # Add order preservation flag to some functions
 exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]
+exp-more-hashes = ["sha2"]
 
 [dependencies]
 jrsonnet-evaluator.workspace = true
@@ -36,6 +37,8 @@
 # std.parseYaml, custom library fork is used for C++/golang compatibility
 serde_yaml_with_quirks = "0.8.24"
 
+sha2 = { version = "0.10.6", optional = true }
+
 [build-dependencies]
 jrsonnet-parser.workspace = true
 structdump = { version = "0.2.0", features = ["derive"] }
modifiedcrates/jrsonnet-stdlib/build.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/build.rs
+++ b/crates/jrsonnet-stdlib/build.rs
@@ -19,7 +19,7 @@
 	{
 		let out_dir = env::var("OUT_DIR").unwrap();
 		let dest_path = Path::new(&out_dir).join("stdlib.rs");
-		let mut f = File::create(&dest_path).unwrap();
+		let mut f = File::create(dest_path).unwrap();
 		f.write_all(
 			("#[allow(clippy::redundant_clone)]".to_owned() + &v.to_string())
 				.replace(';', ";\n")
modifiedcrates/jrsonnet-stdlib/src/encoding.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/encoding.rs
+++ b/crates/jrsonnet-stdlib/src/encoding.rs
@@ -1,5 +1,5 @@
 use jrsonnet_evaluator::{
-	error::{Error::RuntimeError, Result},
+	error::{ErrorKind::RuntimeError, Result},
 	function::builtin,
 	typed::{Either, Either2},
 	IBytes, IStr,
modifiedcrates/jrsonnet-stdlib/src/hash.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/hash.rs
+++ b/crates/jrsonnet-stdlib/src/hash.rs
@@ -4,3 +4,10 @@
 pub fn builtin_md5(str: IStr) -> Result<String> {
 	Ok(format!("{:x}", md5::compute(str.as_bytes())))
 }
+
+#[cfg(feature = "exp-more-hashes")]
+#[builtin]
+pub fn builtin_sha256(str: IStr) -> Result<String> {
+	use sha2::digest::Digest;
+	Ok(format!("{:?}", sha2::Sha256::digest(str.as_bytes())))
+}
modifiedcrates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -5,7 +5,7 @@
 };
 
 use jrsonnet_evaluator::{
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	function::{builtin::Builtin, CallLocation, FuncVal, TlaArg},
 	gc::{GcHashMap, TraceBox},
 	tb,
@@ -101,6 +101,8 @@
 		("sort", builtin_sort::INST),
 		// Hash
 		("md5", builtin_md5::INST),
+		#[cfg(feature = "exp-more-hashes")]
+		("sha256", builtin_sha256::INST),
 		// Encoding
 		("encodeUTF8", builtin_encode_utf8::INST),
 		("decodeUTF8", builtin_decode_utf8::INST),
modifiedcrates/jrsonnet-stdlib/src/misc.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/misc.rs
+++ b/crates/jrsonnet-stdlib/src/misc.rs
@@ -1,7 +1,7 @@
 use std::{cell::RefCell, rc::Rc};
 
 use jrsonnet_evaluator::{
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	function::{builtin, ArgLike, CallLocation, FuncVal},
 	throw,
 	typed::{Any, Either2, Either4},
modifiedcrates/jrsonnet-stdlib/src/parse.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/parse.rs
+++ b/crates/jrsonnet-stdlib/src/parse.rs
@@ -1,5 +1,5 @@
 use jrsonnet_evaluator::{
-	error::{Error::RuntimeError, Result},
+	error::{ErrorKind::RuntimeError, Result},
 	function::builtin,
 	typed::Any,
 	IStr, Val,
modifiedcrates/jrsonnet-stdlib/src/strings.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/strings.rs
+++ b/crates/jrsonnet-stdlib/src/strings.rs
@@ -1,5 +1,5 @@
 use jrsonnet_evaluator::{
-	error::{Error::*, Result},
+	error::{ErrorKind::*, Result},
 	function::builtin,
 	typed::{Either2, VecVal, M1},
 	val::ArrValue,
modifiedtests/tests/common.rsdiffbeforeafterboth
--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -29,7 +29,7 @@
 macro_rules! ensure_val_eq {
 	($a:expr, $b:expr) => {{
 		if !::jrsonnet_evaluator::val::equals(&$a.clone(), &$b.clone())? {
-			use ::jrsonnet_evaluator::stdlib::manifest::JsonFormat;
+			use ::jrsonnet_evaluator::manifest::JsonFormat;
 			::jrsonnet_evaluator::throw!(
 				"assertion failed: a != b\na={:#?}\nb={:#?}",
 				$a.manifest(JsonFormat::default())?,
modifiedtests/tests/golden.rsdiffbeforeafterboth
--- a/tests/tests/golden.rs
+++ b/tests/tests/golden.rs
@@ -4,7 +4,7 @@
 };
 
 use jrsonnet_evaluator::{
-	stdlib::manifest::JsonFormat,
+	manifest::JsonFormat,
 	trace::{CompactFormat, PathResolver, TraceFormat},
 	FileImportResolver, State,
 };