git.delta.rocks / jrsonnet / refs/commits / 75beb619a12f

--- a/.envrc
+++ b/.envrc
@@ -3,6 +3,6 @@
 
 use flake
 
-if ! diff .github/hooks/pre-commit .git/hooks/pre-commit >/dev/null; then
+if ! test -d .jj && ! diff .github/hooks/pre-commit .git/hooks/pre-commit >/dev/null; then
 echo -e "${RED}Hooks are updated, read .github/hooks/pre-commit, and then install it with cp .github/hooks/pre-commit .git/hooks/pre-commit${RESET}"
 fi

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,20 +8,20 @@
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/CertainLach/jrsonnet"
-version = "0.5.0-pre97"
+version = "0.5.0-pre98"
 
 [workspace.dependencies]
-jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre97" }
-jrsonnet-macros = { path = "./crates/jrsonnet-macros", version = "0.5.0-pre97" }
-jrsonnet-ir = { path = "./crates/jrsonnet-ir", version = "0.5.0-pre97" }
-jrsonnet-ir-parser = { path = "./crates/jrsonnet-ir-parser", version = "0.5.0-pre97" }
-jrsonnet-peg-parser = { path = "./crates/jrsonnet-peg-parser", version = "0.5.0-pre97" }
-jrsonnet-rowan-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }
-jrsonnet-interner = { path = "./crates/jrsonnet-interner", version = "0.5.0-pre97" }
-jrsonnet-stdlib = { path = "./crates/jrsonnet-stdlib", version = "0.5.0-pre97" }
-jrsonnet-cli = { path = "./crates/jrsonnet-cli", version = "0.5.0-pre97" }
-jrsonnet-types = { path = "./crates/jrsonnet-types", version = "0.5.0-pre97" }
-jrsonnet-formatter = { path = "./crates/jrsonnet-formatter", version = "0.5.0-pre97" }
+jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre98" }
+jrsonnet-macros = { path = "./crates/jrsonnet-macros", version = "0.5.0-pre98" }
+jrsonnet-ir = { path = "./crates/jrsonnet-ir", version = "0.5.0-pre98" }
+jrsonnet-ir-parser = { path = "./crates/jrsonnet-ir-parser", version = "0.5.0-pre98" }
+jrsonnet-peg-parser = { path = "./crates/jrsonnet-peg-parser", version = "0.5.0-pre98" }
+jrsonnet-rowan-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre98" }
+jrsonnet-interner = { path = "./crates/jrsonnet-interner", version = "0.5.0-pre98" }
+jrsonnet-stdlib = { path = "./crates/jrsonnet-stdlib", version = "0.5.0-pre98" }
+jrsonnet-cli = { path = "./crates/jrsonnet-cli", version = "0.5.0-pre98" }
+jrsonnet-types = { path = "./crates/jrsonnet-types", version = "0.5.0-pre98" }
+jrsonnet-formatter = { path = "./crates/jrsonnet-formatter", version = "0.5.0-pre98" }
 jrsonnet-gcmodule = { version = "0.4.2" }
 # Diagnostics.
 # hi-doc is my library, which handles text formatting very well, but isn't polished enough yet

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -39,5 +39,8 @@
 interop-threading = []
 
 experimental = ["exp-preserve-order", "exp-destruct"]
-exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order", "jrsonnet-stdlib/exp-preserve-order"]
+exp-preserve-order = [
+  "jrsonnet-evaluator/exp-preserve-order",
+  "jrsonnet-stdlib/exp-preserve-order",
+]
 exp-destruct = ["jrsonnet-evaluator/exp-destruct"]

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -5,16 +5,15 @@
 	cell::RefCell,
 	collections::HashMap,
 	env::current_dir,
-	ffi::{c_void, CStr, CString},
+	ffi::{CStr, CString, c_void},
 	os::raw::{c_char, c_int},
 	path::PathBuf,
 	ptr::null_mut,
 };
 
 use jrsonnet_evaluator::{
-	bail,
+	AsPathLike, ImportResolver, ResolvePath, bail,
 	error::{ErrorKind::*, Result},
-	AsPathLike, ImportResolver, ResolvePath,
 };
 use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_ir::{SourceDirectory, SourceFile, SourcePath};

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -21,14 +21,13 @@
 };
 
 use jrsonnet_evaluator::{
-	apply_tla, bail,
+	AsPathLike, FileImportResolver, IStr, ImportResolver, Result, State, Val, apply_tla, bail,
 	gc::WithCapacityExt as _,
 	manifest::{JsonFormat, ManifestFormat, ToStringFormat},
 	rustc_hash::FxHashMap,
 	stack::set_stack_depth_limit,
 	tla::TlaArg,
 	trace::{CompactFormat, PathResolver, TraceFormat},
-	AsPathLike, FileImportResolver, IStr, ImportResolver, Result, State, Val,
 };
 use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_ir::SourcePath;

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -1,13 +1,13 @@
 use std::{
-	ffi::{c_void, CStr},
+	ffi::{CStr, c_void},
 	os::raw::{c_char, c_int},
 };
 
 use jrsonnet_evaluator::{
+	IStr, Val,
 	error::{Error, ErrorKind},
 	function::builtin::{NativeCallback, NativeCallbackHandler},
 	typed::FromUntyped as _,
-	IStr, Val,
 };
 
 use crate::VM;

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -6,8 +6,8 @@
 };
 
 use jrsonnet_evaluator::{
+	ObjValue, Val,
 	val::{ArrValue, NumValue},
-	ObjValue, Val,
 };
 
 use crate::VM;

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -4,7 +4,7 @@
 
 use std::{ffi::CStr, os::raw::c_char};
 
-use jrsonnet_evaluator::{val::ArrValue, Thunk, Val};
+use jrsonnet_evaluator::{Thunk, Val, val::ArrValue};
 
 use crate::VM;
 

--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -2,8 +2,7 @@
 
 use std::{ffi::CStr, os::raw::c_char};
 
-use jrsonnet_evaluator::tla::TlaArg;
-use jrsonnet_evaluator::IStr;
+use jrsonnet_evaluator::{IStr, tla::TlaArg};
 
 use crate::VM;
 

--- a/cmds/jrsonnet-deps/src/main.rs
+++ b/cmds/jrsonnet-deps/src/main.rs
@@ -1,12 +1,10 @@
-use std::collections::BTreeSet;
-use std::process::exit;
+use std::{collections::BTreeSet, process::exit};
 
 use clap::Parser;
+use jrsonnet_cli::MiscOpts;
 use jrsonnet_evaluator::{FileImportResolver, ImportResolver};
-use jrsonnet_ir::{visit::Visitor, IStr, Source, SourcePath};
+use jrsonnet_ir::{IStr, Source, SourcePath, visit::Visitor};
 use jrsonnet_ir_parser::ParserSettings;
-
-use jrsonnet_cli::MiscOpts;
 
 #[derive(Parser)]
 struct Opts {

--- a/cmds/jrsonnet-fmt/src/main.rs
+++ b/cmds/jrsonnet-fmt/src/main.rs
@@ -6,7 +6,7 @@
 };
 
 use clap::Parser;
-use jrsonnet_formatter::{format, FormatOptions};
+use jrsonnet_formatter::{FormatOptions, format};
 
 #[derive(Parser)]
 #[allow(clippy::struct_excessive_bools)]
@@ -51,8 +51,12 @@
 }
 
 fn main_result() -> Result<(), Error> {
-	eprintln!("jrsonnet-fmt is a prototype of a jsonnet code formatter, do not expect it to produce meaningful results right now.");
-	eprintln!("It is not expected for its output to match other implementations, it will be completly separate implementation with maybe different name.");
+	eprintln!(
+		"jrsonnet-fmt is a prototype of a jsonnet code formatter, do not expect it to produce meaningful results right now."
+	);
+	eprintln!(
+		"It is not expected for its output to match other implementations, it will be completly separate implementation with maybe different name."
+	);
 	let mut opts = Opts::parse();
 	let input = if opts.exec {
 		if opts.in_place {

--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -12,19 +12,19 @@
 
 [features]
 experimental = [
-    "exp-preserve-order",
-    "exp-destruct",
-    "exp-null-coaelse",
-    "exp-object-iteration",
-    "exp-bigint",
-    "exp-apply",
+  "exp-preserve-order",
+  "exp-destruct",
+  "exp-null-coaelse",
+  "exp-object-iteration",
+  "exp-bigint",
+  "exp-apply",
 ]
 # Use mimalloc as allocator
 mimalloc = ["mimallocator"]
 # Experimental feature, which allows to preserve order of object fields
 exp-preserve-order = [
-    "jrsonnet-evaluator/exp-preserve-order",
-    "jrsonnet-cli/exp-preserve-order",
+  "jrsonnet-evaluator/exp-preserve-order",
+  "jrsonnet-cli/exp-preserve-order",
 ]
 # Destructuring of locals
 exp-destruct = ["jrsonnet-evaluator/exp-destruct"]
@@ -36,9 +36,9 @@
 exp-regex = ["jrsonnet-cli/exp-regex"]
 # obj?.field, obj?.['field']
 exp-null-coaelse = [
-    "jrsonnet-evaluator/exp-null-coaelse",
-    "jrsonnet-ir/exp-null-coaelse",
-    "jrsonnet-cli/exp-null-coaelse",
+  "jrsonnet-evaluator/exp-null-coaelse",
+  "jrsonnet-ir/exp-null-coaelse",
+  "jrsonnet-cli/exp-null-coaelse",
 ]
 # --exp-apply
 exp-apply = []

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -1,5 +1,5 @@
 use std::{
-	fs::{create_dir_all, File},
+	fs::{File, create_dir_all},
 	io::{Read, Write},
 };
 
@@ -7,9 +7,8 @@
 use clap_complete::Shell;
 use jrsonnet_cli::{GcOpts, ManifestOpts, MiscOpts, OutputOpts, StdOpts, TlaOpts, TraceOpts};
 use jrsonnet_evaluator::{
-	apply_tla, bail,
+	ResultExt, State, Val, apply_tla, bail,
 	error::{Error as JrError, ErrorKind},
-	ResultExt, State, Val,
 };
 use jrsonnet_ir::{SourceDefaultIgnoreJpath, SourcePath};
 

--- a/crates/jrsonnet-cli/Cargo.toml
+++ b/crates/jrsonnet-cli/Cargo.toml
@@ -12,20 +12,15 @@
 
 [features]
 exp-preserve-order = [
-    "jrsonnet-evaluator/exp-preserve-order",
-    "jrsonnet-stdlib/exp-preserve-order",
-]
-exp-bigint = [
-    "jrsonnet-evaluator/exp-bigint",
-    "jrsonnet-stdlib/exp-bigint",
+  "jrsonnet-evaluator/exp-preserve-order",
+  "jrsonnet-stdlib/exp-preserve-order",
 ]
+exp-bigint = ["jrsonnet-evaluator/exp-bigint", "jrsonnet-stdlib/exp-bigint"]
 exp-null-coaelse = [
-    "jrsonnet-evaluator/exp-null-coaelse",
-    "jrsonnet-stdlib/exp-null-coaelse",
+  "jrsonnet-evaluator/exp-null-coaelse",
+  "jrsonnet-stdlib/exp-null-coaelse",
 ]
-exp-regex = [
-    "jrsonnet-stdlib/exp-regex",
-]
+exp-regex = ["jrsonnet-stdlib/exp-regex"]
 
 [dependencies]
 jrsonnet-evaluator = { workspace = true, features = ["explaining-traces"] }

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -7,10 +7,10 @@
 
 use clap::Parser;
 use jrsonnet_evaluator::{
-	stack::{limit_stack_depth, StackDepthLimitOverrideGuard},
 	FileImportResolver,
+	stack::{StackDepthLimitOverrideGuard, limit_stack_depth},
 };
-use jrsonnet_gcmodule::{with_thread_object_space, ObjectSpace};
+use jrsonnet_gcmodule::{ObjectSpace, with_thread_object_space};
 pub use manifest::*;
 pub use stdlib::*;
 pub use tla::*;

--- a/crates/jrsonnet-cli/src/stdlib.rs
+++ b/crates/jrsonnet-cli/src/stdlib.rs
@@ -1,8 +1,7 @@
 use std::str::FromStr;
 
 use clap::Parser;
-use jrsonnet_evaluator::tla::TlaArg;
-use jrsonnet_evaluator::{trace::PathResolver, Result};
+use jrsonnet_evaluator::{Result, tla::TlaArg, trace::PathResolver};
 use jrsonnet_stdlib::ContextInitializer;
 
 #[derive(Clone)]

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,6 +1,7 @@
 use clap::Parser;
-use jrsonnet_evaluator::tla::TlaArg;
-use jrsonnet_evaluator::{error::Result, gc::WithCapacityExt as _, rustc_hash::FxHashMap, IStr};
+use jrsonnet_evaluator::{
+	IStr, error::Result, gc::WithCapacityExt as _, rustc_hash::FxHashMap, tla::TlaArg,
+};
 
 use crate::{ExtFile, ExtStr};
 

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -26,13 +26,19 @@
 # Allows to preserve field order in objects
 exp-preserve-order = []
 # Implements field destructuring
-exp-destruct = ["jrsonnet-peg-parser?/exp-destruct", "jrsonnet-ir-parser?/exp-destruct"]
+exp-destruct = [
+  "jrsonnet-peg-parser?/exp-destruct",
+  "jrsonnet-ir-parser?/exp-destruct",
+]
 # Iteration over objects yields [key, value] elements
 exp-object-iteration = []
 # Bigint type
 exp-bigint = ["num-bigint", "jrsonnet-types/exp-bigint"]
 # obj?.field, obj?.['field']
-exp-null-coaelse = ["jrsonnet-peg-parser?/exp-null-coaelse", "jrsonnet-ir-parser?/exp-null-coaelse"]
+exp-null-coaelse = [
+  "jrsonnet-peg-parser?/exp-null-coaelse",
+  "jrsonnet-ir-parser?/exp-null-coaelse",
+]
 
 [dependencies]
 jrsonnet-interner.workspace = true
@@ -63,7 +69,13 @@
 num-bigint = { workspace = true, features = ["serde"], optional = true }
 
 stacker = "0.1.23"
-educe = { version = "0.6.0", default-features = false, features = ["Clone", "Debug", "Eq", "Hash", "PartialEq"] }
+educe = { version = "0.6.0", default-features = false, features = [
+  "Clone",
+  "Debug",
+  "Eq",
+  "Hash",
+  "PartialEq",
+] }
 
 [build-dependencies]
 rustversion = "1.0.22"

--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -5,11 +5,11 @@
 	rc::Rc,
 };
 
-use jrsonnet_gcmodule::{cc_dyn, Cc};
+use jrsonnet_gcmodule::{Cc, cc_dyn};
 use jrsonnet_interner::IBytes;
 use jrsonnet_ir::Expr;
 
-use crate::{function::NativeFn, typed::IntoUntyped, Context, Result, Thunk, Val};
+use crate::{Context, Result, Thunk, Val, function::NativeFn, typed::IntoUntyped};
 
 mod spec;
 pub use spec::{ArrayLike, *};

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -1,18 +1,17 @@
-use std::rc::Rc;
-use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace};
+use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace, rc::Rc};
 
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::{IBytes, IStr};
 use jrsonnet_ir::Expr;
 
 use super::ArrValue;
-use crate::function::NativeFn;
 use crate::{
+	Context, Error, ObjValue, Result, Thunk, Val,
 	error::ErrorKind::InfiniteRecursionDetected,
 	evaluate,
+	function::NativeFn,
 	typed::{IntoUntyped, Typed},
 	val::ThunkValue,
-	Context, Error, ObjValue, Result, Thunk, Val,
 };
 
 pub trait ArrayLike: Any + Trace + Debug {

--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -1,9 +1,7 @@
-use std::rc::Rc;
-use std::{any::Any, cell::RefCell, future::Future};
+use std::{any::Any, cell::RefCell, future::Future, rc::Rc};
 
 use jrsonnet_gcmodule::Acyclic;
-use jrsonnet_ir::visit::Visitor;
-use jrsonnet_ir::{IStr, Source, SourcePath};
+use jrsonnet_ir::{IStr, Source, SourcePath, visit::Visitor};
 use rustc_hash::FxHashMap;
 
 use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -6,8 +6,8 @@
 use rustc_hash::FxHashMap;
 
 use crate::{
-	error::ErrorKind::*, gc::WithCapacityExt as _, map::LayeredHashMap, ObjValue, Pending, Result,
-	SupThis, Thunk, Val,
+	ObjValue, Pending, Result, SupThis, Thunk, Val, error::ErrorKind::*, gc::WithCapacityExt as _,
+	map::LayeredHashMap,
 };
 /// Context keeps information about current lexical code location
 ///

--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -3,7 +3,7 @@
 use educe::Educe;
 use jrsonnet_gcmodule::{Cc, Trace};
 
-use crate::{bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue, Result};
+use crate::{Result, bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue};
 
 #[derive(Trace, Educe)]
 #[educe(Clone)]

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -7,11 +7,11 @@
 use thiserror::Error;
 
 use crate::{
+	ObjValue, ResolvePathOwned,
 	function::{CallLocation, FunctionSignature, ParamName},
 	stdlib::format::FormatError,
 	typed::TypeLocError,
 	val::ConvertNumValueError,
-	ObjValue, ResolvePathOwned,
 };
 
 #[derive(Debug, Clone)]
@@ -78,7 +78,10 @@
 		if conf < 0.8 {
 			continue;
 		}
-		assert!(field.as_str() != key.as_str(), "looks like string pooling failure, please write any info regarding this crash to https://github.com/CertainLach/jrsonnet/issues/113, thanks!");
+		assert!(
+			field.as_str() != key.as_str(),
+			"looks like string pooling failure, please write any info regarding this crash to https://github.com/CertainLach/jrsonnet/issues/113, thanks!"
+		);
 
 		heap.push((conf, field));
 	}
@@ -271,11 +274,11 @@
 }
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		writeln!(f, "{}", self.0 .0)?;
-		for el in &self.0 .1 .0 {
+		writeln!(f, "{}", self.0.0)?;
+		for el in &self.0.1.0 {
 			write!(f, "\t{}", el.desc)?;
 			if let Some(loc) = &el.location {
-				write!(f, "at {}", loc.0 .0 .0)?;
+				write!(f, "at {}", loc.0.0.0)?;
 				loc.0.map_source_locations(&[loc.1, loc.2]);
 			}
 			writeln!(f)?;

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -3,15 +3,14 @@
 use jrsonnet_interner::IStr;
 use jrsonnet_ir::{BindSpec, Destruct};
 
+#[cfg(feature = "exp-preserve-order")]
+use crate::evaluate;
 use crate::{
-	bail,
+	Context, Pending, Thunk, Val, bail,
 	error::{ErrorKind::*, Result},
-	evaluate_method, evaluate_named_param, Context, Pending, Thunk, Val,
+	evaluate_method, evaluate_named_param,
 };
 
-#[cfg(feature = "exp-preserve-order")]
-use crate::evaluate;
-
 #[allow(clippy::too_many_lines)]
 #[allow(unused_variables)]
 pub fn destruct<H: BuildHasher>(
@@ -107,10 +106,11 @@
 		}
 		#[cfg(feature = "exp-destruct")]
 		Destruct::Object { fields, rest } => {
-			use crate::ObjValueBuilder;
 			use jrsonnet_ir::DestructRest;
 			use rustc_hash::FxHashSet;
 
+			use crate::ObjValueBuilder;
+
 			let captured_fields: FxHashSet<_> = fields.iter().map(|f| f.0.clone()).collect();
 			let field_names: Vec<_> = fields
 				.iter()

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -3,27 +3,28 @@
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_ir::{
-	function::ParamName, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams,
-	FieldMember, FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers,
-	Spanned,
+	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams, FieldMember,
+	FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers, Spanned,
+	function::ParamName,
 };
 use jrsonnet_types::ValType;
 use rustc_hash::FxHashMap;
 
 use self::destructure::destruct;
 use crate::{
+	Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, ResultExt,
+	SupThis, Unbound, Val,
 	arr::ArrValue,
 	bail,
 	destructure::evaluate_dest,
-	error::{suggest_object_fields, ErrorKind::*},
+	error::{ErrorKind::*, suggest_object_fields},
 	evaluate::operator::{evaluate_binary_op_special, evaluate_unary_op},
 	function::{CallLocation, FuncDesc, FuncVal},
 	gc::WithCapacityExt as _,
 	in_frame,
 	typed::{FromUntyped, IntoUntyped as _, Typed},
 	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},
-	with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,
-	ResultExt, SupThis, Unbound, Val,
+	with_state,
 };
 pub mod destructure;
 pub mod operator;

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -3,14 +3,14 @@
 use jrsonnet_ir::{BinaryOpType, Expr, UnaryOpType};
 
 use crate::{
+	Context, Result, Val,
 	arr::ArrValue,
 	bail,
 	error::ErrorKind::*,
 	evaluate,
 	stdlib::std_format,
 	typed::IntoUntyped as _,
-	val::{equals, StrValue},
-	Context, Result, Val,
+	val::{StrValue, equals},
 };
 
 pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -1,6 +1,6 @@
 use std::any::Any;
 
-use jrsonnet_gcmodule::{cc_dyn, Trace, TraceBox};
+use jrsonnet_gcmodule::{Trace, TraceBox, cc_dyn};
 use jrsonnet_ir::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};
 
 use super::CallLocation;

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -9,11 +9,11 @@
 use self::{
 	builtin::{Builtin, StaticBuiltin},
 	parse::{parse_builtin_call, parse_default_function_call, parse_function_call},
-	prepared::{parse_prepared_builtin_call, parse_prepared_function_call, PreparedCall},
+	prepared::{PreparedCall, parse_prepared_builtin_call, parse_prepared_function_call},
 };
 use crate::{
-	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,
-	Result, Thunk, Val,
+	Context, Result, Thunk, Val, bail, error::ErrorKind::*, evaluate, evaluate_trivial,
+	function::builtin::BuiltinFunc,
 };
 
 pub mod builtin;
@@ -21,10 +21,9 @@
 mod parse;
 mod prepared;
 
+pub use jrsonnet_ir::function::*;
 pub use native::NativeFn;
 pub use prepared::PreparedFuncVal;
-
-pub use jrsonnet_ir::function::*;
 
 /// Function callsite location.
 /// Either from other jsonnet code, specified by expression location, or from native (without location).

--- a/crates/jrsonnet-evaluator/src/function/native.rs
+++ b/crates/jrsonnet-evaluator/src/function/native.rs
@@ -1,14 +1,14 @@
 use std::marker::PhantomData;
 
 use jrsonnet_gcmodule::Trace;
+use jrsonnet_types::{ComplexValType, ValType};
 
 use super::PreparedFuncVal;
 use crate::{
+	CallLocation, Result, Val,
 	function::FuncVal,
 	typed::{FromUntyped, IntoUntyped, Typed},
-	CallLocation, Result, Val,
 };
-use jrsonnet_types::{ComplexValType, ValType};
 
 #[derive(Debug, Trace, Clone)]
 pub struct NativeFn<D: 'static>(pub(crate) PreparedFuncVal, PhantomData<D>);

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -1,18 +1,17 @@
 use std::rc::Rc;
 
 use jrsonnet_ir::{
+	ArgsDesc, Expr, ExprParams,
 	function::{FunctionSignature, ParamName},
-	ArgsDesc, Expr, ExprParams,
 };
 use rustc_hash::FxHashMap;
 
 use crate::{
-	bail,
+	Context, Pending, Thunk, Val, bail,
 	destructure::destruct,
 	error::{ErrorKind::*, Result},
 	evaluate, evaluate_named_param,
 	gc::WithCapacityExt as _,
-	Context, Pending, Thunk, Val,
 };
 
 fn eval_arg(ctx: Context, arg: &Rc<Expr>, tailstrict: bool) -> Result<Thunk<Val>> {

--- a/crates/jrsonnet-evaluator/src/function/prepared.rs
+++ b/crates/jrsonnet-evaluator/src/function/prepared.rs
@@ -1,16 +1,14 @@
 use std::rc::Rc;
 
 use jrsonnet_gcmodule::{Acyclic, Trace};
-use jrsonnet_ir::function::FunctionSignature;
-use jrsonnet_ir::{ExprParams, IStr};
+use jrsonnet_ir::{ExprParams, IStr, function::FunctionSignature};
 use rustc_hash::{FxHashMap, FxHashSet};
-
-use crate::destructure::destruct;
-use crate::gc::WithCapacityExt;
-use crate::{bail, error::ErrorKind::*, Result};
-use crate::{evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};
 
 use super::{CallLocation, FuncVal};
+use crate::{
+	Context, ContextBuilder, Pending, Result, Thunk, Val, bail, destructure::destruct,
+	error::ErrorKind::*, evaluate_named_param, gc::WithCapacityExt,
+};
 
 #[derive(Debug, Trace, Clone)]
 pub struct PreparedFuncVal {

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -2,17 +2,17 @@
 
 use jrsonnet_interner::IStr;
 use serde::{
+	Deserialize, Serialize, Serializer,
 	de::{self, Visitor},
 	ser::{
 		Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
 		SerializeTupleStruct, SerializeTupleVariant,
 	},
-	Deserialize, Serialize, Serializer,
 };
 
 use crate::{
-	arr::ArrValue, in_description_frame, runtime_error, val::NumValue, Error as JrError, ObjValue,
-	ObjValueBuilder, Result, Val,
+	Error as JrError, ObjValue, ObjValueBuilder, Result, Val, arr::ArrValue, in_description_frame,
+	runtime_error, val::NumValue,
 };
 
 impl<'de> Deserialize<'de> for Val {

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -40,7 +40,7 @@
 pub use evaluate::*;
 use function::CallLocation;
 pub use import::*;
-use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};
+use jrsonnet_gcmodule::{Cc, Trace, cc_dyn};
 pub use jrsonnet_interner::{IBytes, IStr};
 pub use jrsonnet_ir as parser;
 use jrsonnet_ir::{Expr, Source, SourcePath};

--- a/crates/jrsonnet-evaluator/src/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/manifest.rs
@@ -1,6 +1,6 @@
 use std::{borrow::Cow, fmt::Write, ptr};
 
-use crate::{bail, in_description_frame, Result, ResultExt, Val};
+use crate::{Result, ResultExt, Val, bail, in_description_frame};
 
 pub trait ManifestFormat {
 	fn manifest_buf(&self, val: Val, buf: &mut String) -> Result<()>;

--- a/crates/jrsonnet-evaluator/src/map.rs
+++ b/crates/jrsonnet-evaluator/src/map.rs
@@ -2,7 +2,7 @@
 use jrsonnet_interner::IStr;
 use rustc_hash::FxHashMap;
 
-use crate::{gc::WithCapacityExt as _, Thunk, Val};
+use crate::{Thunk, Val, gc::WithCapacityExt as _};
 
 #[derive(Trace, Debug)]
 #[trace(tracking(force))]

--- a/crates/jrsonnet-evaluator/src/obj/mod.rs
+++ b/crates/jrsonnet-evaluator/src/obj/mod.rs
@@ -11,7 +11,7 @@
 };
 
 use educe::Educe;
-use jrsonnet_gcmodule::{cc_dyn, Acyclic, Cc, Trace, Weak};
+use jrsonnet_gcmodule::{Acyclic, Cc, Trace, Weak, cc_dyn};
 use jrsonnet_interner::IStr;
 use jrsonnet_ir::Span;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -22,13 +22,13 @@
 pub use oop::ObjValueBuilder;
 
 use crate::{
+	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,
 	arr::{PickObjectKeyValues, PickObjectValues},
 	bail,
-	error::{suggest_object_fields, ErrorKind::*},
+	error::{ErrorKind::*, suggest_object_fields},
 	identity_hash,
 	operator::evaluate_add_op,
 	val::{ArrValue, ThunkValue},
-	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,
 };
 
 #[cfg(not(feature = "exp-preserve-order"))]

--- a/crates/jrsonnet-evaluator/src/obj/oop.rs
+++ b/crates/jrsonnet-evaluator/src/obj/oop.rs
@@ -1,21 +1,25 @@
-use std::cell::{Cell, RefCell};
-use std::ops::ControlFlow;
-use std::{fmt, mem};
+use std::{
+	cell::{Cell, RefCell},
+	fmt, mem,
+	ops::ControlFlow,
+};
 
-use crate::function::{CallLocation, FuncVal};
-use crate::gc::WithCapacityExt as _;
-use crate::{
-	bail, error::ErrorKind::*, in_frame, CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,
-};
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_ir::IStr;
 use rustc_hash::{FxHashMap, FxHashSet};
 
-use super::ordering::{FieldIndex, SuperDepth};
 use super::{
 	CcObjectAssertion, CcObjectCore, EnumFields, EnumFieldsHandler, FieldVisibility, GetFor,
 	HasFieldIncludeHidden, ObjMember, ObjMemberBuilder, ObjValue, ObjValueInner, ObjectAssertion,
 	ObjectCore, OmitFieldsCore, SupThis,
+	ordering::{FieldIndex, SuperDepth},
+};
+use crate::{
+	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val, bail,
+	error::ErrorKind::*,
+	function::{CallLocation, FuncVal},
+	gc::WithCapacityExt as _,
+	in_frame,
 };
 
 #[allow(clippy::module_name_repetitions)]

--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -7,10 +7,9 @@
 use thiserror::Error;
 
 use crate::{
-	bail,
-	error::{format_found, suggest_object_fields, ErrorKind::*},
+	Error, ObjValue, Result, Val, bail,
+	error::{ErrorKind::*, format_found, suggest_object_fields},
 	typed::FromUntyped,
-	Error, ObjValue, Result, Val,
 };
 
 #[derive(Debug, Clone, Error, Trace)]

--- a/crates/jrsonnet-evaluator/src/stdlib/mod.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/mod.rs
@@ -3,7 +3,7 @@
 
 use format::{format_arr, format_obj};
 
-use crate::{function::CallLocation, in_frame, Result, Val};
+use crate::{Result, Val, function::CallLocation, in_frame};
 
 pub mod format;
 

--- a/crates/jrsonnet-evaluator/src/tla.rs
+++ b/crates/jrsonnet-evaluator/src/tla.rs
@@ -5,8 +5,9 @@
 use jrsonnet_ir::{SourceFifo, SourcePath};
 
 use crate::{
+	Result, Thunk, Val,
 	function::{CallLocation, PreparedFuncVal},
-	in_description_frame, with_state, Result, Thunk, Val,
+	in_description_frame, with_state,
 };
 
 #[derive(Clone, Trace)]

--- a/crates/jrsonnet-evaluator/src/trace/mod.rs
+++ b/crates/jrsonnet-evaluator/src/trace/mod.rs
@@ -10,7 +10,7 @@
 #[cfg(feature = "explaining-traces")]
 use jrsonnet_ir::Span;
 
-use crate::{error::ErrorKind, Error};
+use crate::{Error, error::ErrorKind};
 
 /// The way paths should be displayed
 #[derive(Clone, Trace)]
@@ -258,7 +258,7 @@
 		struct ResetData {
 			loc: Span,
 		}
-		use hi_doc::{source_to_ansi, Formatting, SnippetBuilder, Text};
+		use hi_doc::{Formatting, SnippetBuilder, Text, source_to_ansi};
 
 		write!(out, "{}", error.error())?;
 		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {