git.delta.rocks / jrsonnet / refs/commits / 5df60b8b674f

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -43,7 +43,7 @@
 		}
 		n_args.push(None);
 		let mut success = 1;
-		let v = unsafe { (self.cb)(self.ctx, n_args.as_ptr().cast(), &mut success) };
+		let v = unsafe { (self.cb)(self.ctx, n_args.as_ptr().cast(), &raw mut success) };
 		let v = unsafe { *Box::from_raw(v) };
 		if success == 1 {
 			Ok(v)

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -7,6 +7,7 @@
 
 #[derive(Parser)]
 #[clap(next_help_heading = "TOP LEVEL ARGUMENTS")]
+#[allow(clippy::struct_field_names)]
 pub struct TlaOpts {
 	/// Add top level string argument.
 	/// Top level arguments will be passed to function before manifestification stage.

--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -77,7 +77,7 @@
 			let i = i?;
 			if filter(&i)? {
 				out.push(i);
-			};
+			}
 		}
 		Ok(Self::eager(out))
 	}

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -38,7 +38,7 @@
 }
 impl ArrayLike for SliceArray {
 	fn len(&self) -> usize {
-		((self.to - self.from + self.step - 1) / self.step) as usize
+		(self.to - self.from).div_ceil(self.step) as usize
 	}
 
 	fn get(&self, index: usize) -> Result<Option<Val>> {
@@ -139,7 +139,7 @@
 			ArrayThunk::Errored(e) => return Err(e.clone()),
 			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),
 			ArrayThunk::Waiting => {}
-		};
+		}
 
 		let ArrayThunk::Waiting =
 			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
@@ -158,15 +158,6 @@
 		Ok(Some(new_value))
 	}
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		if index >= self.len() {
-			return None;
-		}
-		match &self.cached.borrow()[index] {
-			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
-			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
-			ArrayThunk::Waiting | ArrayThunk::Pending => {}
-		};
-
 		#[derive(Trace)]
 		struct ExprArrThunk {
 			expr: ExprArray,
@@ -183,6 +174,15 @@
 			}
 		}
 
+		if index >= self.len() {
+			return None;
+		}
+		match &self.cached.borrow()[index] {
+			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
+			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
+			ArrayThunk::Waiting | ArrayThunk::Pending => {}
+		}
+
 		Some(Thunk::new(ExprArrThunk {
 			expr: self.clone(),
 			index,
@@ -441,7 +441,7 @@
 			ArrayThunk::Errored(e) => return Err(e.clone()),
 			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),
 			ArrayThunk::Waiting => {}
-		};
+		}
 
 		let ArrayThunk::Waiting =
 			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
@@ -467,15 +467,6 @@
 		Ok(Some(new_value))
 	}
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		if index >= self.len() {
-			return None;
-		}
-		match &self.cached.borrow()[index] {
-			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
-			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
-			ArrayThunk::Waiting | ArrayThunk::Pending => {}
-		};
-
 		#[derive(Trace)]
 		struct MappedArrayThunk<const WITH_INDEX: bool> {
 			arr: MappedArray<WITH_INDEX>,
@@ -489,6 +480,15 @@
 			}
 		}
 
+		if index >= self.len() {
+			return None;
+		}
+		match &self.cached.borrow()[index] {
+			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
+			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
+			ArrayThunk::Waiting | ArrayThunk::Pending => {}
+		}
+
 		Some(Thunk::new(MappedArrayThunk {
 			arr: self.clone(),
 			index,

--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -21,7 +21,8 @@
 // Visits all nodes, trying to find import statements
 #[allow(clippy::too_many_lines)]
 pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {
-	fn in_destruct(dest: &Destruct, #[allow(unused_variables)] out: &mut FoundImports) {
+	#[allow(unused_variables, clippy::needless_pass_by_ref_mut)]
+	fn in_destruct(dest: &Destruct, out: &mut FoundImports) {
 		match dest {
 			#[cfg(feature = "exp-destruct")]
 			Destruct::Array {
@@ -295,8 +296,6 @@
 	let resolved = (s.import_resolver() as &dyn Any)
 		.downcast_ref::<ResolvedImportResolver>()
 		.expect("for async imports, import_resolver should be set to ResolvedImportResolver");
-
-	let mut resolved_map = resolved.resolved.borrow_mut();
 
 	let mut queue = vec![Job::LoadFile {
 		path: handler.resolve_from_default(path).await?,
@@ -340,14 +339,17 @@
 				}
 			}
 			Job::ResolveImport { from, import } => {
-				if let Some((resolved, expression)) =
-					resolved_map.get_mut(&(from.clone(), import.path.clone()))
 				{
-					if import.expression && !*expression {
-						*expression = true;
-						queue.push(Job::ParseFile(resolved.clone()));
+					let mut resolved_map = resolved.resolved.borrow_mut();
+					if let Some((resolved, expression)) =
+						resolved_map.get_mut(&(from.clone(), import.path.clone()))
+					{
+						if import.expression && !*expression {
+							*expression = true;
+							queue.push(Job::ParseFile(resolved.clone()));
+						}
+						continue;
 					}
-					continue;
 				}
 				let resolved = handler.resolve_from(&from, &import.path).await?;
 				queue.push(Job::LoadFile {

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -1,6 +1,7 @@
+use std::{collections::HashMap, hash::BuildHasher};
+
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{BindSpec, Destruct};
-use rustc_hash::FxHashMap;
 
 use crate::{
 	bail,
@@ -10,11 +11,11 @@
 
 #[allow(clippy::too_many_lines)]
 #[allow(unused_variables)]
-pub fn destruct(
+pub fn destruct<H: BuildHasher>(
 	d: &Destruct,
 	parent: Thunk<Val>,
 	fctx: Pending<Context>,
-	new_bindings: &mut FxHashMap<IStr, Thunk<Val>>,
+	new_bindings: &mut HashMap<IStr, Thunk<Val>, H>,
 ) -> Result<()> {
 	match d {
 		Destruct::Full(v) => {
@@ -159,10 +160,10 @@
 	Ok(())
 }
 
-pub fn evaluate_dest(
+pub fn evaluate_dest<H: BuildHasher>(
 	d: &BindSpec,
 	fctx: Pending<Context>,
-	new_bindings: &mut FxHashMap<IStr, Thunk<Val>>,
+	new_bindings: &mut HashMap<IStr, Thunk<Val>, H>,
 ) -> Result<()> {
 	match d {
 		BindSpec::Field { into, value } => {

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -291,7 +291,7 @@
 	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));
 
 	for field in &members.fields {
-		evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), &field)?;
+		evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;
 	}
 
 	if !members.asserts.is_empty() {
@@ -304,13 +304,13 @@
 			fn run(&self, sup_this: SupThis) -> Result<()> {
 				let ctx = self.uctx.bind(sup_this)?;
 				for assert in &*self.asserts {
-					evaluate_assert(ctx.clone(), &assert)?;
+					evaluate_assert(ctx.clone(), assert)?;
 				}
 				Ok(())
 			}
 		}
 		builder.assert(ObjectAssert {
-			uctx: uctx.clone(),
+			uctx,
 			asserts: members.asserts.clone(),
 		});
 	}
@@ -567,7 +567,7 @@
 				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
 			}
 			let ctx = ctx.extend_bindings(new_bindings).into_future(fctx);
-			evaluate(ctx, &returned.clone())?
+			evaluate(ctx, returned)?
 		}
 		Arr(items) => {
 			if items.is_empty() {

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -95,9 +95,9 @@
 		// string format
 		(Str(_), _) => false,
 
-		(_, Num(b)) => return **b == 0.,
+		(_, Num(b)) => **b == 0.,
 		#[cfg(feature = "exp-bigint")]
-		(_, BigInt(b)) => return **b == num_bigint::BigInt::ZERO,
+		(_, BigInt(b)) => **b == num_bigint::BigInt::ZERO,
 
 		// something else
 		_ => false,

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -239,7 +239,7 @@
 	}
 
 	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
-		for (name, _) in self {
+		for name in self.keys() {
 			handler(name);
 		}
 	}

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -1,5 +1,3 @@
-use std::mem::replace;
-
 use jrsonnet_parser::{
 	function::{FunctionSignature, ParamName},
 	ExprParams,
@@ -87,7 +85,7 @@
 			}
 
 			destruct(
-				&into,
+				into,
 				{
 					let ctx = fctx.clone();
 					let name = into.name();
@@ -97,7 +95,7 @@
 				fctx.clone(),
 				&mut defaults,
 			)?;
-			if !into.name().is_anonymous() {
+			if into.name().is_named() {
 				filled_named += 1;
 			} else {
 				filled_positionals += 1;
@@ -165,7 +163,7 @@
 			.iter()
 			.position(|p| p.name() == name)
 			.ok_or_else(|| UnknownFunctionParameter(name.clone()))?;
-		if replace(&mut passed_args[id], Some(arg)).is_some() {
+		if passed_args[id].replace(arg).is_some() {
 			bail!(BindingParameterASecondTime(name.clone()));
 		}
 		filled_args += 1;
@@ -230,7 +228,7 @@
 					let params = params.clone();
 					Thunk!(move || Err(FunctionParameterNotBoundInCall(
 						param_name,
-						params.signature.clone()
+						params.signature
 					)
 					.into()))
 				},

--- a/crates/jrsonnet-evaluator/src/gc.rs
+++ b/crates/jrsonnet-evaluator/src/gc.rs
@@ -1,3 +1,8 @@
+#![allow(
+	clippy::implicit_hasher,
+	reason = "those methods exist exactly because with_capacity is only present for default BuildHasher"
+)]
+
 /// Macros to help deal with Gc
 use jrsonnet_gcmodule::Trace;
 use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
@@ -8,20 +13,20 @@
 }
 impl<V> WithCapacityExt for FxHashSet<V> {
 	fn with_capacity(capacity: usize) -> Self {
-		Self::with_capacity_and_hasher(capacity, FxBuildHasher::default())
+		Self::with_capacity_and_hasher(capacity, FxBuildHasher)
 	}
 
 	fn new() -> Self {
-		Self::with_hasher(FxBuildHasher::default())
+		Self::with_hasher(FxBuildHasher)
 	}
 }
 impl<K, V> WithCapacityExt for FxHashMap<K, V> {
 	fn with_capacity(capacity: usize) -> Self {
-		Self::with_capacity_and_hasher(capacity, FxBuildHasher::default())
+		Self::with_capacity_and_hasher(capacity, FxBuildHasher)
 	}
 
 	fn new() -> Self {
-		Self::with_hasher(FxBuildHasher::default())
+		Self::with_hasher(FxBuildHasher)
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -367,7 +367,7 @@
 		let res = evaluate(self.create_default_context(file_name), &parsed);
 
 		let mut file_cache = self.file_cache();
-		let mut file = file_cache.entry(path.clone());
+		let mut file = file_cache.entry(path);
 
 		let Entry::Occupied(file) = &mut file else {
 			unreachable!("this file was just here")

--- a/crates/jrsonnet-evaluator/src/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/manifest.rs
@@ -240,7 +240,7 @@
 					}
 					ToString if i != 0 => buf.push(' '),
 					Minify | ToString => {}
-				};
+				}
 
 				in_description_frame(
 					|| format!("elem <{i}> manifestification"),
@@ -335,7 +335,7 @@
 			buf.push('}');
 		}
 		Val::Func(_) => bail!("tried to manifest function"),
-	};
+	}
 	Ok(())
 }
 

--- a/crates/jrsonnet-evaluator/src/map.rs
+++ b/crates/jrsonnet-evaluator/src/map.rs
@@ -16,7 +16,7 @@
 
 impl LayeredHashMap {
 	pub fn iter_keys(self, mut handler: impl FnMut(IStr)) {
-		for (k, _) in &self.0.current {
+		for k in self.0.current.keys() {
 			handler(k.clone());
 		}
 		if let Some(parent) = self.0.parent.clone() {
@@ -47,11 +47,7 @@
 
 	pub fn contains_key(&self, key: &IStr) -> bool {
 		(self.0).current.contains_key(key)
-			|| self
-				.0
-				.parent
-				.as_ref()
-				.map_or(false, |p| p.contains_key(key))
+			|| self.0.parent.as_ref().is_some_and(|p| p.contains_key(key))
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/obj/mod.rs
+++ b/crates/jrsonnet-evaluator/src/obj/mod.rs
@@ -1,6 +1,7 @@
 use std::{
 	any::Any,
 	cell::{Cell, RefCell},
+	clone::Clone,
 	collections::hash_map::Entry,
 	fmt::{self, Debug},
 	hash::{Hash, Hasher},
@@ -272,7 +273,7 @@
 
 impl ObjValue {
 	pub fn empty() -> Self {
-		EMPTY_OBJ.with(|v| v.clone())
+		EMPTY_OBJ.with(Clone::clone)
 	}
 	pub fn is_empty(&self) -> bool {
 		self.0.cores.is_empty() || self.len() == 0
@@ -306,14 +307,13 @@
 			return Ok(GetFor::NotFound);
 		}
 		let v = self.this.get_idx(key, self.sup)?;
-		Ok(v.map_or(GetFor::NotFound, |v| GetFor::Final(v)))
+		Ok(v.map_or(GetFor::NotFound, GetFor::Final))
 	}
 
 	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {
-		match self.this.field_visibility_idx(field, self.sup) {
-			Some(c) => FieldVisibility::Found(c),
-			None => FieldVisibility::NotFound,
-		}
+		self.this
+			.field_visibility_idx(field, self.sup)
+			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)
 	}
 
 	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {

--- a/crates/jrsonnet-evaluator/src/obj/oop.rs
+++ b/crates/jrsonnet-evaluator/src/obj/oop.rs
@@ -1,4 +1,4 @@
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::ops::ControlFlow;
 use std::{fmt, mem};
 
@@ -105,7 +105,7 @@
 
 	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()> {
 		if let Some(assertion) = &self.assertion {
-			assertion.0.run(sup_this.clone())?;
+			assertion.0.run(sup_this)?;
 		}
 		Ok(())
 	}
@@ -196,7 +196,7 @@
 		ObjValue(Cc::new(ObjValueInner {
 			cores: self.sup,
 			assertions_ran: Cell::new(false),
-			value_cache: Default::default(),
+			value_cache: RefCell::default(),
 		}))
 	}
 }

--- a/crates/jrsonnet-evaluator/src/stack.rs
+++ b/crates/jrsonnet-evaluator/src/stack.rs
@@ -17,6 +17,7 @@
 	}
 }
 #[cfg(not(nightly))]
+#[allow(dead_code)]
 type NightlyLocalKey<T> = std::thread::LocalKey<T>;
 
 #[cfg(nightly)]
@@ -60,7 +61,7 @@
 pub struct StackDepthGuard(PhantomData<()>);
 impl Drop for StackDepthGuard {
 	fn drop(&mut self) {
-		STACK_LIMIT.with(|limit| limit.current_depth.set(limit.current_depth.get() - 1))
+		STACK_LIMIT.with(|limit| limit.current_depth.set(limit.current_depth.get() - 1));
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/tla.rs
+++ b/crates/jrsonnet-evaluator/src/tla.rs
@@ -1,13 +1,14 @@
+use std::{collections::HashMap, hash::BuildHasher};
+
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::Source;
-use rustc_hash::FxHashMap;
 
 use crate::{
 	function::{CallLocation, TlaArg},
 	in_description_frame, with_state, Result, Val,
 };
 
-pub fn apply_tla(args: &FxHashMap<IStr, TlaArg>, val: Val) -> Result<Val> {
+pub fn apply_tla<H: BuildHasher>(args: &HashMap<IStr, TlaArg, H>, val: Val) -> Result<Val> {
 	Ok(if let Val::Func(func) = val {
 		in_description_frame(
 			|| "during TLA call".to_owned(),

--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -462,7 +462,7 @@
 		};
 		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {
 			return Ok(bytes.0.as_slice().into());
-		};
+		}
 		<Self as Typed>::TYPE.check(&value)?;
 		// Any::downcast_ref::<ByteArray>(&a);
 		let mut out = Vec::with_capacity(a.len());

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -65,7 +65,7 @@
 			MemoizedClusureThunkInner::Errored(e) => return Err(e.clone()),
 			MemoizedClusureThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),
 			MemoizedClusureThunkInner::Waiting { .. } => (),
-		};
+		}
 		let MemoizedClusureThunkInner::Waiting { env, closure } = replace(
 			&mut *self.0.borrow_mut(),
 			MemoizedClusureThunkInner::Pending,
@@ -288,14 +288,11 @@
 			Self::Str(s) => {
 				let mut computed_len = None;
 				let mut get_len = || {
-					computed_len.map_or_else(
-						|| {
-							let len = s.chars().count();
-							let _ = computed_len.insert(len);
-							len
-						},
-						|len| len,
-					)
+					computed_len.unwrap_or_else(|| {
+						let len = s.chars().count();
+						let _ = computed_len.insert(len);
+						len
+					})
 				};
 				let mut get_idx = |pos: Option<i32>, default| {
 					match pos {
@@ -446,7 +443,7 @@
 	pub const fn get(&self) -> f64 {
 		self.0
 	}
-	pub(crate) fn truncate_for_bitwise(&self) -> Result<i64> {
+	pub(crate) fn truncate_for_bitwise(self) -> Result<i64> {
 		if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {
 			bail!("numberic value outside of safe integer range for bitwise operation");
 		}

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -227,9 +227,11 @@
 type PoolMap = HashMap<Inner, (), FxBuildHasher>;
 
 thread_local! {
-	static POOL: RefCell<PoolMap> = RefCell::new(HashMap::with_capacity_and_hasher(200, FxBuildHasher::default()));
+	static POOL: RefCell<PoolMap> = RefCell::new(HashMap::with_capacity_and_hasher(200, FxBuildHasher));
 }
 
+/// Utils for embedding jrsonnet in non-rust.
+///
 /// Jrsonnet golang bindings require that it is possible to move jsonnet
 /// VM between OS threads, and this is not possible due to usage of
 /// `thread_local`. Instead, there is two methods added, one should be

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -127,6 +127,7 @@
 	Default(Expr),
 }
 
+#[allow(clippy::large_enum_variant, reason = "this macro is not that hot for it to matter")]
 enum ArgInfo {
 	Normal {
 		ty: Box<Type>,

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -166,6 +166,10 @@
 	pub fn len(&self) -> usize {
 		self.exprs.len()
 	}
+	pub fn is_empty(&self) -> bool {
+		self.exprs.is_empty()
+	}
+
 	pub fn binds_len(&self) -> usize {
 		self.binds_len
 	}

--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -98,9 +98,9 @@
 			for c in str.chars() {
 				match func(Either2::A(c.to_string()))? {
 					Val::Str(o) => write!(out, "{o}").unwrap(),
-					Val::Null => continue,
+					Val::Null => {},
 					_ => bail!("in std.join all items should be strings"),
-				};
+				}
 			}
 			Ok(IndexableVal::Str(out.into()))
 		}
@@ -114,9 +114,9 @@
 							out.push(oe?);
 						}
 					}
-					Val::Null => continue,
+					Val::Null => {},
 					_ => bail!("in std.join all items should be arrays"),
-				};
+				}
 			}
 			Ok(IndexableVal::Arr(out.into()))
 		}
@@ -205,7 +205,6 @@
 						out.push(item?);
 					}
 				} else if matches!(item, Val::Null) {
-					continue;
 				} else {
 					bail!("in std.join all items should be arrays");
 				}
@@ -226,7 +225,6 @@
 					first = false;
 					write!(out, "{item}").unwrap();
 				} else if matches!(item, Val::Null) {
-					continue;
 				} else {
 					bail!("in std.join all items should be strings");
 				}

--- a/crates/jrsonnet-stdlib/src/manifest/xml.rs
+++ b/crates/jrsonnet-stdlib/src/manifest/xml.rs
@@ -46,7 +46,7 @@
 		};
 		if arr.is_empty() {
 			bail!("JSONML value should have tag (array length should be >=1)");
-		};
+		}
 		let tag = String::from_untyped(
 			arr.get(0)
 				.description("getting JSONML tag")?

--- a/crates/jrsonnet-stdlib/src/manifest/yaml.rs
+++ b/crates/jrsonnet-stdlib/src/manifest/yaml.rs
@@ -90,6 +90,7 @@
 		RESERVED.iter().any(|k| key.eq_ignore_ascii_case(k))
 	}
 
+	#[allow(clippy::if_same_then_else)]
 	// Check for unsafe characters
 	if !key
 		.chars()
@@ -98,7 +99,7 @@
 		return false;
 	}
 	// Check for reserved words
-	if is_reserved(key) {
+	else if is_reserved(key) {
 		return false;
 	}
 	// Check for timestamp values.  Since spaces and colons are already forbidden,
@@ -107,7 +108,7 @@
 	// - all characters match [0-9\-]
 	// - has exactly 2 dashes
 	// are considered dates.
-	if key.chars().all(|v| matches!(v, '0'..='9' | '-')) && count_char(key, '-') == 2 {
+	else if key.chars().all(|v| matches!(v, '0'..='9' | '-')) && count_char(key, '-') == 2 {
 		return false;
 	}
 	// Check for integers.  Keys that meet all of the following:

--- a/crates/jrsonnet-stdlib/src/misc.rs
+++ b/crates/jrsonnet-stdlib/src/misc.rs
@@ -172,7 +172,7 @@
 	let Some(patch) = patch.as_obj() else {
 		return Ok(patch);
 	};
-	let target = target.as_obj().unwrap_or_else(|| ObjValue::empty());
+	let target = target.as_obj().unwrap_or_else(ObjValue::empty);
 	let target_fields = target
 		.fields(
 			// FIXME: Makes no sense to preserve order for BTreeSet, it would be better to use IndexSet here?

--- a/crates/jrsonnet-stdlib/src/sets.rs
+++ b/crates/jrsonnet-stdlib/src/sets.rs
@@ -21,7 +21,7 @@
 	let x = keyF(x)?;
 
 	while low < high {
-		let middle = (high + low) / 2;
+		let middle = usize::midpoint(high, low);
 		let comp = keyF(arr.get_lazy(middle).expect("in bounds"))?;
 		match evaluate_compare_op(&comp, &x, BinaryOpType::Lt)? {
 			Ordering::Less => low = middle + 1,
@@ -66,7 +66,7 @@
 				bv = b.next();
 				bk = bv.map(keyF).transpose()?;
 			}
-		};
+		}
 	}
 	Ok(ArrValue::lazy(out))
 }
@@ -106,7 +106,7 @@
 				bv = b.next();
 				bk = bv.map(keyF).transpose()?;
 			}
-		};
+		}
 	}
 	while let Some(_ac) = &ak {
 		// In a, but not in b
@@ -154,7 +154,7 @@
 				bv = b.next();
 				bk = bv.clone().map(keyF).transpose()?;
 			}
-		};
+		}
 	}
 	// a.len() > b.len()
 	while let Some(_ac) = &ak {

--- a/crates/jrsonnet-stdlib/src/sort.rs
+++ b/crates/jrsonnet-stdlib/src/sort.rs
@@ -66,7 +66,7 @@
 				return Err(err);
 			}
 		}
-	};
+	}
 	Ok(values)
 }
 
@@ -107,7 +107,7 @@
 				return Err(err);
 			}
 		}
-	};
+	}
 	Ok(vk.into_iter().map(|v| v.0).collect())
 }
 
@@ -204,7 +204,7 @@
 	}
 }
 
-fn eval_keyf(val: Val, key_f: &Option<FuncVal>) -> Result<Val> {
+fn eval_keyf(val: Val, key_f: Option<&FuncVal>) -> Result<Val> {
 	if let Some(key_f) = key_f {
 		key_f.evaluate_simple(&(val,), false)
 	} else {
@@ -212,13 +212,13 @@
 	}
 }
 
-fn array_top1(arr: ArrValue, key_f: Option<FuncVal>, ordering: Ordering) -> Result<Val> {
+fn array_top1(arr: ArrValue, key_f: Option<&FuncVal>, ordering: Ordering) -> Result<Val> {
 	let mut iter = arr.iter();
 	let mut min = iter.next().expect("not empty")?;
-	let mut min_key = eval_keyf(min.clone(), &key_f)?;
+	let mut min_key = eval_keyf(min.clone(), key_f)?;
 	for item in iter {
 		let cur = item?;
-		let cur_key = eval_keyf(cur.clone(), &key_f)?;
+		let cur_key = eval_keyf(cur.clone(), key_f)?;
 		if evaluate_compare_op(&cur_key, &min_key, BinaryOpType::Lt)? == ordering {
 			min = cur;
 			min_key = cur_key;
@@ -236,7 +236,7 @@
 	if arr.is_empty() {
 		return eval_on_empty(onEmpty);
 	}
-	array_top1(arr, keyF, Ordering::Less)
+	array_top1(arr, keyF.as_ref(), Ordering::Less)
 }
 #[builtin]
 pub fn builtin_max_array(
@@ -247,5 +247,5 @@
 	if arr.is_empty() {
 		return eval_on_empty(onEmpty);
 	}
-	array_top1(arr, keyF, Ordering::Greater)
+	array_top1(arr, keyF.as_ref(), Ordering::Greater)
 }

--- a/crates/jrsonnet-stdlib/src/strings.rs
+++ b/crates/jrsonnet-stdlib/src/strings.rs
@@ -53,7 +53,7 @@
 
 #[builtin]
 pub fn builtin_equals_ignore_case(str1: String, str2: String) -> bool {
-	str1.to_ascii_lowercase() == str2.to_ascii_lowercase()
+	str1.eq_ignore_ascii_case(&str2)
 }
 
 #[builtin]

--- a/crates/jrsonnet-types/src/lib.rs
+++ b/crates/jrsonnet-types/src/lib.rs
@@ -133,7 +133,7 @@
 			Self::Sum(v) => write_union(f, false, v.iter())?,
 			Self::SumRef(v) => write_union(f, false, v.iter().copied())?,
 			Self::Lazy(lazy) => write!(f, "Lazy<{lazy}>")?,
-		};
+		}
 		Ok(())
 	}
 }

--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -57,12 +57,13 @@
 #[builtin]
 fn param_names(fun: FuncVal) -> Vec<String> {
 	fun.params()
-		.into_iter()
+		.iter()
 		.map(|v| v.name().as_str().unwrap_or("<unnamed>").to_owned())
 		.collect()
 }
 
 #[derive(Trace)]
+#[allow(dead_code)]
 pub struct ContextInitializer;
 impl ContextInitializerT for ContextInitializer {
 	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {

--- a/tests/tests/cpp_test_suite.rs
+++ b/tests/tests/cpp_test_suite.rs
@@ -23,29 +23,29 @@
 	// C++ test suite
 	std_context.add_ext_str("var1".into(), "test".into());
 	std_context
-		.add_ext_code("var2".into(), "{x:1,y:2}")
+		.add_ext_code("var2", "{x:1,y:2}")
 		.expect("code is valid");
 
 	// Golang test suite
 	std_context
-		.add_ext_code("codeVar".into(), "3+3")
+		.add_ext_code("codeVar", "3+3")
 		.expect("code is valid");
 	std_context.add_ext_str("stringVar".into(), "2 + 2".into());
 	std_context
 		.add_ext_code(
-			"selfRecursiveVar".into(),
+			"selfRecursiveVar",
 			r#"[42, std.extVar("selfRecursiveVar")[0] + 1]"#,
 		)
 		.expect("code is valid");
 	std_context
 		.add_ext_code(
-			"mutuallyRecursiveVar1".into(),
+			"mutuallyRecursiveVar1",
 			r#"[42, std.extVar("mutuallyRecursiveVar2")[0] + 1]"#,
 		)
 		.expect("code is valid");
 	std_context
 		.add_ext_code(
-			"mutuallyRecursiveVar2".into(),
+			"mutuallyRecursiveVar2",
 			r#"[42, std.extVar("mutuallyRecursiveVar1")[0] + 1]"#,
 		)
 		.expect("code is valid");
@@ -203,9 +203,9 @@
 		let root = root_tests.join(root_dir);
 		let root_override = root_tests.join(format!("{root_dir}_golden_override"));
 
-		for entry in fs::read_dir(&root).map_err(|e| io::Error::new(ErrorKind::Other, format!("failed to enumerate cpp_test_suite dir (Note: it needs to be cloned from C++ jsonnet repo for this test): {e}")))? {
+		for entry in fs::read_dir(&root).map_err(|e| io::Error::other(format!("failed to enumerate cpp_test_suite dir (Note: it needs to be cloned from C++ jsonnet repo for this test): {e}")))? {
 		let entry = entry?;
-		if !entry.path().extension().map_or(false, |e| e == "jsonnet") {
+		if entry.path().extension().is_none_or(|e| e != "jsonnet") {
 			continue;
 		}
 
@@ -213,7 +213,7 @@
 			.path()
 			.file_name()
 			.and_then(|v| v.to_str())
-			.map_or(false, |v| SKIPPED.contains(&v))
+			.is_some_and(|v| SKIPPED.contains(&v))
 		{
 			continue;
 		}
@@ -227,7 +227,7 @@
 		golden_path2.set_extension("golden");
 
 		let golden_override =
-			root_override.join(&golden_path.file_name().expect("file has basename"));
+			root_override.join(golden_path.file_name().expect("file has basename"));
 
 		// .jsonnet.golden for C++ tests
 		let mut golden = read_file(&golden_path)?;
@@ -282,7 +282,7 @@
 					}
 				}
 			}
-		};
+		}
 	}
 	}
 

--- a/tests/tests/golden.rs
+++ b/tests/tests/golden.rs
@@ -40,8 +40,8 @@
 #[test]
 fn golden() {
 	glob!("../", "golden/*.jsonnet", |path| {
-		let result = run(&path);
+		let result = run(path);
 
-		assert_snapshot!(result)
+		assert_snapshot!(result);
 	});
 }

--- a/tests/tests/suite.rs
+++ b/tests/tests/suite.rs
@@ -32,7 +32,7 @@
 			file.display(),
 			trace_format.format(&e).unwrap()
 		),
-	};
+	}
 }
 
 #[test]
@@ -42,11 +42,9 @@
 
 	for entry in fs::read_dir(&root)? {
 		let entry = entry?;
-		if !entry.path().extension().map_or(false, |e| e == "jsonnet") {
-			continue;
+		if entry.path().extension().is_some_and(|e| e == "jsonnet") {
+			run(&entry.path());
 		}
-
-		run(&entry.path());
 	}
 
 	Ok(())