git.delta.rocks / jrsonnet / refs/commits / 7af406eaa740

1use std::{2	cell::RefCell,3	cmp::Ordering,4	fmt::{self, Debug, Display},5	marker::PhantomData,6	mem::replace,7	num::NonZeroU32,8	ops::Deref,9	rc::Rc,10};1112use jrsonnet_gcmodule::{Acyclic, Cc, Trace, cc_dyn};13use jrsonnet_interner::IStr;14pub use jrsonnet_macros::Thunk;15use jrsonnet_types::ValType;16use rustc_hash::FxHashMap;17use thiserror::Error;1819pub use crate::arr::{ArrValue, ArrayLike};20use crate::{21	ObjValue, Result, SupThis, Unbound, WeakSupThis, bail,22	error::{Error, ErrorKind::*},23	function::FuncVal,24	gc::WithCapacityExt as _,25	manifest::{ManifestFormat, ToStringFormat},26	typed::{BoundedUsize, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER},27};2829pub trait ThunkValue: Trace {30	type Output;31	fn get(&self) -> Result<Self::Output>;32}3334#[derive(Trace)]35enum MemoizedClusureThunkInner<D: Trace, T: Trace> {36	Computed(T),37	Errored(Error),38	Waiting {39		env: D,40		// Carries no data, as it is not a real closure, all the41		// captured environment is stored in `env` field.42		#[trace(skip)]43		closure: fn(D) -> Result<T>,44	},45	Pending,46}47#[derive(Trace)]48pub struct MemoizedClosureThunk<D: Trace, T: Trace>(RefCell<MemoizedClusureThunkInner<D, T>>);49impl<D: Trace, T: Trace> MemoizedClosureThunk<D, T> {50	pub fn new(env: D, closure: fn(D) -> Result<T>) -> Self {51		Self(RefCell::new(MemoizedClusureThunkInner::Waiting {52			env,53			closure,54		}))55	}56}5758impl<D: Trace, T: Trace + Clone> ThunkValue for MemoizedClosureThunk<D, T> {59	type Output = T;6061	fn get(&self) -> Result<Self::Output> {62		match &*self.0.borrow() {63			MemoizedClusureThunkInner::Computed(v) => return Ok(v.clone()),64			MemoizedClusureThunkInner::Errored(e) => return Err(e.clone()),65			MemoizedClusureThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),66			MemoizedClusureThunkInner::Waiting { .. } => (),67		}68		let MemoizedClusureThunkInner::Waiting { env, closure } = replace(69			&mut *self.0.borrow_mut(),70			MemoizedClusureThunkInner::Pending,71		) else {72			unreachable!();73		};74		let new_value = match closure(env) {75			Ok(v) => v,76			Err(e) => {77				*self.0.borrow_mut() = MemoizedClusureThunkInner::Errored(e.clone());78				return Err(e);79			}80		};81		*self.0.borrow_mut() = MemoizedClusureThunkInner::Computed(new_value.clone());82		Ok(new_value)83	}84}8586cc_dyn!(87	/// Lazily evaluated value88	#[derive(Clone)] Thunk<V: Trace>,89	ThunkValue<Output = V>,90	pub fn new() {...}91);9293impl<T: Trace> Thunk<T> {94	pub fn evaluated(val: T) -> Self95	where96		T: Clone,97	{98		#[derive(Trace)]99		struct EvaluatedThunk<T: Trace>(T);100		impl<T> ThunkValue for EvaluatedThunk<T>101		where102			T: Clone + Trace,103		{104			type Output = T;105106			fn get(&self) -> Result<Self::Output> {107				Ok(self.0.clone())108			}109		}110		Self::new(EvaluatedThunk(val))111	}112	pub fn errored(e: Error) -> Self {113		#[derive(Trace)]114		struct ErroredThunk<T: Trace>(Error, PhantomData<T>);115		impl<T> ThunkValue for ErroredThunk<T>116		where117			T: Trace,118		{119			type Output = T;120121			fn get(&self) -> Result<Self::Output> {122				Err(self.0.clone())123			}124		}125		Self::new(ErroredThunk(e, PhantomData))126	}127	pub fn result(res: Result<T, Error>) -> Self128	where129		T: Clone,130	{131		match res {132			Ok(o) => Self::evaluated(o),133			Err(e) => Self::errored(e),134		}135	}136}137138impl<T> Thunk<T>139where140	T: Trace,141{142	pub fn force(&self) -> Result<()> {143		self.evaluate()?;144		Ok(())145	}146147	/// Evaluate thunk, or return cached value148	///149	/// # Errors150	///151	/// - Lazy value evaluation returned error152	/// - This method was called during inner value evaluation153	pub fn evaluate(&self) -> Result<T> {154		self.0.get()155	}156}157158pub trait ThunkMapper<Input>: Trace {159	type Output;160	fn map(self, from: Input) -> Result<Self::Output>;161}162impl<Input> Thunk<Input>163where164	Input: Trace,165{166	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>167	where168		M: ThunkMapper<Input>,169		M::Output: Trace + Clone,170	{171		let inner = self;172		Thunk!(move || {173			let value = inner.evaluate()?;174			let mapped = mapper.map(value)?;175			Ok(mapped)176		})177	}178}179180impl<T: Trace + Clone> From<Result<T>> for Thunk<T> {181	fn from(value: Result<T>) -> Self {182		match value {183			Ok(o) => Self::evaluated(o),184			Err(e) => Self::errored(e),185		}186	}187}188impl<T, V: Trace> From<T> for Thunk<V>189where190	T: ThunkValue<Output = V>,191{192	fn from(value: T) -> Self {193		Self::new(value)194	}195}196197impl<T: Trace + Default + Clone> Default for Thunk<T> {198	fn default() -> Self {199		Self::evaluated(T::default())200	}201}202203#[derive(Trace, Clone)]204pub struct CachedUnbound<I, T>205where206	I: Unbound<Bound = T>,207	T: Trace,208{209	cache: Cc<RefCell<FxHashMap<WeakSupThis, T>>>,210	value: I,211}212impl<I: Unbound<Bound = T>, T: Trace> CachedUnbound<I, T> {213	pub fn new(value: I) -> Self {214		Self {215			cache: Cc::new(RefCell::new(FxHashMap::new())),216			value,217		}218	}219}220impl<I: Unbound<Bound = T>, T: Clone + Trace> Unbound for CachedUnbound<I, T> {221	type Bound = T;222	fn bind(&self, sup_this: SupThis) -> Result<T> {223		let cache_key = sup_this.clone().downgrade();224		{225			if let Some(t) = self.cache.borrow().get(&cache_key) {226				return Ok(t.clone());227			}228		}229		let bound = self.value.bind(sup_this)?;230231		{232			let mut cache = self.cache.borrow_mut();233			cache.insert(cache_key, bound.clone());234		}235236		Ok(bound)237	}238}239240impl<T: Debug + Trace> Debug for Thunk<T> {241	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {242		write!(f, "Lazy")243	}244}245impl<T: Trace> PartialEq for Thunk<T> {246	fn eq(&self, other: &Self) -> bool {247		Cc::ptr_eq(&self.0, &other.0)248	}249}250251/// Represents a Jsonnet value, which can be sliced or indexed (string or array).252#[allow(clippy::module_name_repetitions)]253pub enum IndexableVal {254	/// String.255	Str(IStr),256	/// Array.257	Arr(ArrValue),258}259impl IndexableVal {260	pub fn is_empty(&self) -> bool {261		match self {262			Self::Str(s) => s.is_empty(),263			Self::Arr(s) => s.is_empty(),264		}265	}266267	pub fn to_array(self) -> ArrValue {268		match self {269			Self::Str(s) => s.chars().collect(),270			Self::Arr(arr) => arr,271		}272	}273	/// Slice the value.274	///275	/// # Implementation276	///277	/// For strings, will create a copy of specified interval.278	///279	/// For arrays, nothing will be copied on this call, instead [`ArrValue::Slice`] view will be returned.280	pub fn slice(281		self,282		index: Option<i32>,283		end: Option<i32>,284		step: Option<BoundedUsize<1, { i32::MAX as usize }>>,285	) -> Result<Self> {286		match &self {287			Self::Str(s) => {288				let mut computed_len = None;289				let mut get_len = || {290					computed_len.unwrap_or_else(|| {291						let len = s.chars().count();292						let _ = computed_len.insert(len);293						len294					})295				};296				let mut get_idx = |pos: Option<i32>, default| {297					match pos {298						#[expect(clippy::cast_sign_loss, reason = "abs value is used")]299						Some(v) if v < 0 => get_len().saturating_sub((-v as isize) as usize),300						// No need to clamp, as iterator interface is used301						#[expect(clippy::cast_sign_loss, reason = "abs value is used")]302						Some(v) => v as usize,303						None => default,304					}305				};306307				let index = get_idx(index, 0);308				let end = get_idx(end, usize::MAX);309				let step = step.as_deref().copied().unwrap_or(1);310311				if index >= end {312					return Ok(Self::Str("".into()));313				}314315				Ok(Self::Str(316					(s.chars()317						.skip(index)318						.take(end - index)319						.step_by(step)320						.collect::<String>())321					.into(),322				))323			}324			Self::Arr(arr) => Ok(Self::Arr(arr.clone().slice(325				index,326				end,327				#[expect(328					clippy::cast_possible_truncation,329					reason = "overflow will result with skip too large which would be equivalent"330				)]331				step.map(|v| NonZeroU32::new(v.value() as u32).expect("bounded != 0")),332			))),333		}334	}335}336337#[derive(Debug, Clone, Acyclic)]338pub enum StrValue {339	Flat(IStr),340	Tree(Rc<(StrValue, StrValue, usize)>),341}342impl StrValue {343	pub fn concat(a: Self, b: Self) -> Self {344		// TODO: benchmark for an optimal value, currently just a arbitrary choice345		const STRING_EXTEND_THRESHOLD: usize = 100;346347		if a.is_empty() {348			b349		} else if b.is_empty() {350			a351		} else if a.len() + b.len() < STRING_EXTEND_THRESHOLD {352			Self::Flat(format!("{a}{b}").into())353		} else {354			let len = a.len() + b.len();355			Self::Tree(Rc::new((a, b, len)))356		}357	}358	pub fn chunks(&self, c: &mut impl FnMut(&IStr)) {359		fn write_buf(s: &StrValue, c: &mut impl FnMut(&IStr)) {360			match s {361				StrValue::Flat(f) => c(f),362				StrValue::Tree(t) => {363					write_buf(&t.0, c);364					write_buf(&t.1, c);365				}366			}367		}368		write_buf(self, c);369	}370	pub fn into_flat(&self) -> IStr {371		fn write_buf(s: &StrValue, out: &mut String) {372			match s {373				StrValue::Flat(f) => out.push_str(f),374				StrValue::Tree(t) => {375					write_buf(&t.0, out);376					write_buf(&t.1, out);377				}378			}379		}380		match self {381			Self::Flat(f) => f.clone(),382			Self::Tree(_) => {383				let mut buf = String::with_capacity(self.len());384				write_buf(self, &mut buf);385				buf.into()386			}387		}388	}389	pub fn len(&self) -> usize {390		match self {391			Self::Flat(v) => v.len(),392			Self::Tree(t) => t.2,393		}394	}395	pub fn is_empty(&self) -> bool {396		match self {397			Self::Flat(v) => v.is_empty(),398			// Can't create non-flat empty string399			Self::Tree(_) => false,400		}401	}402}403impl<T> From<T> for StrValue404where405	IStr: From<T>,406{407	fn from(value: T) -> Self {408		Self::Flat(IStr::from(value))409	}410}411impl Display for StrValue {412	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {413		match self {414			Self::Flat(v) => write!(f, "{v}"),415			Self::Tree(t) => {416				write!(f, "{}", t.0)?;417				write!(f, "{}", t.1)418			}419		}420	}421}422impl PartialEq for StrValue {423	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.424	#[allow(clippy::unconditional_recursion)]425	fn eq(&self, other: &Self) -> bool {426		let a = self.clone().into_flat();427		let b = other.clone().into_flat();428		a == b429	}430}431impl Eq for StrValue {}432impl PartialOrd for StrValue {433	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {434		Some(self.cmp(other))435	}436}437impl Ord for StrValue {438	fn cmp(&self, other: &Self) -> Ordering {439		let a = self.clone().into_flat();440		let b = other.clone().into_flat();441		a.cmp(&b)442	}443}444445/// Represents jsonnet number446/// Jsonnet numbers are finite f64, with NaNs disallowed447#[derive(Trace, Clone, Copy)]448#[repr(transparent)]449pub struct NumValue(f64);450impl NumValue {451	/// Creates a [`NumValue`], if value is finite and not NaN452	pub fn new(v: f64) -> Option<Self> {453		if !v.is_finite() {454			return None;455		}456		Some(Self(v))457	}458	#[inline]459	pub const fn get(&self) -> f64 {460		self.0461	}462	pub(crate) fn truncate_for_bitwise(self) -> Result<i64> {463		if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {464			bail!("numberic value outside of safe integer range for bitwise operation");465		}466		#[expect(clippy::cast_possible_truncation, reason = "intended")]467		Ok(self.0 as i64)468	}469}470impl PartialEq for NumValue {471	fn eq(&self, other: &Self) -> bool {472		self.0 == other.0473	}474}475impl Eq for NumValue {}476impl Ord for NumValue {477	#[inline]478	fn cmp(&self, other: &Self) -> Ordering {479		// Can't use `total_cmp`: its behavior for `-0` and `0`480		// is not following wanted.481		unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }482	}483}484impl PartialOrd for NumValue {485	#[inline]486	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {487		Some(self.cmp(other))488	}489}490impl Debug for NumValue {491	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {492		Debug::fmt(&self.0, f)493	}494}495impl Display for NumValue {496	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {497		Display::fmt(&self.0, f)498	}499}500impl Deref for NumValue {501	type Target = f64;502503	#[inline]504	fn deref(&self) -> &Self::Target {505		&self.0506	}507}508macro_rules! impl_num {509	($($ty:ty),+) => {$(510		impl From<$ty> for NumValue {511			#[inline]512			fn from(value: $ty) -> Self {513				Self(value.into())514			}515		}516	)+};517}518impl_num!(i8, u8, i16, u16, i32, u32);519520#[derive(Clone, Copy, Debug, Error, Trace)]521pub enum ConvertNumValueError {522	#[error("overflow")]523	Overflow,524	#[error("underflow")]525	Underflow,526	#[error("non-finite")]527	NonFinite,528}529impl From<ConvertNumValueError> for Error {530	fn from(e: ConvertNumValueError) -> Self {531		Self::new(e.into())532	}533}534535macro_rules! impl_try_num {536	($($ty:ty),+) => {$(537		impl TryFrom<$ty> for NumValue {538			type Error = ConvertNumValueError;539			#[inline]540			fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {541				#[expect(clippy::cast_precision_loss, reason = "precision loss is explicitly handled")]542				let value = value as f64;543				if value < MIN_SAFE_INTEGER {544					return Err(ConvertNumValueError::Underflow)545				} else if value > MAX_SAFE_INTEGER {546					return Err(ConvertNumValueError::Overflow)547				}548				// Number is finite.549				Ok(Self(value))550			}551		}552	)+};553}554impl_try_num!(usize, isize, i64, u64);555556impl TryFrom<f64> for NumValue {557	type Error = ConvertNumValueError;558559	#[inline]560	fn try_from(value: f64) -> Result<Self, Self::Error> {561		Self::new(value).ok_or(ConvertNumValueError::NonFinite)562	}563}564impl TryFrom<f32> for NumValue {565	type Error = ConvertNumValueError;566567	#[inline]568	fn try_from(value: f32) -> Result<Self, Self::Error> {569		Self::new(f64::from(value)).ok_or(ConvertNumValueError::NonFinite)570	}571}572573/// Represents any valid Jsonnet value.574#[derive(Debug, Clone, Trace, Default)]575pub enum Val {576	/// Represents a Jsonnet boolean.577	Bool(bool),578	/// Represents a Jsonnet null value.579	#[default]580	Null,581	/// Represents a Jsonnet string.582	Str(StrValue),583	/// Represents a Jsonnet number.584	/// Should be finite, and not NaN585	/// This restriction isn't enforced by enum, as enum field can't be marked as private586	Num(NumValue),587	/// Experimental bigint588	#[cfg(feature = "exp-bigint")]589	BigInt(#[trace(skip)] Box<num_bigint::BigInt>),590	/// Represents a Jsonnet array.591	Arr(ArrValue),592	/// Represents a Jsonnet object.593	Obj(ObjValue),594	/// Represents a Jsonnet function.595	Func(FuncVal),596}597598#[cfg(target_pointer_width = "64")]599static_assertions::assert_eq_size!(Val, [u8; 24]);600601impl From<IndexableVal> for Val {602	fn from(v: IndexableVal) -> Self {603		match v {604			IndexableVal::Str(s) => Self::string(s),605			IndexableVal::Arr(a) => Self::Arr(a),606		}607	}608}609610impl Val {611	pub const fn as_bool(&self) -> Option<bool> {612		match self {613			Self::Bool(v) => Some(*v),614			_ => None,615		}616	}617	pub const fn as_null(&self) -> Option<()> {618		match self {619			Self::Null => Some(()),620			_ => None,621		}622	}623	pub fn as_str(&self) -> Option<IStr> {624		match self {625			Self::Str(s) => Some(s.clone().into_flat()),626			_ => None,627		}628	}629	pub const fn as_num(&self) -> Option<f64> {630		match self {631			Self::Num(n) => Some(n.get()),632			_ => None,633		}634	}635	#[cfg(feature = "exp-bigint")]636	pub fn as_bigint(&self) -> Option<num_bigint::BigInt> {637		match self {638			Self::BigInt(n) => Some(*n.clone()),639			_ => None,640		}641	}642	pub fn as_arr(&self) -> Option<ArrValue> {643		match self {644			Self::Arr(a) => Some(a.clone()),645			_ => None,646		}647	}648	pub fn as_obj(&self) -> Option<ObjValue> {649		match self {650			Self::Obj(o) => Some(o.clone()),651			_ => None,652		}653	}654	pub fn as_func(&self) -> Option<FuncVal> {655		match self {656			Self::Func(f) => Some(f.clone()),657			_ => None,658		}659	}660661	pub const fn value_type(&self) -> ValType {662		match self {663			Self::Str(..) => ValType::Str,664			Self::Num(..) => ValType::Num,665			#[cfg(feature = "exp-bigint")]666			Self::BigInt(..) => ValType::BigInt,667			Self::Arr(..) => ValType::Arr,668			Self::Obj(..) => ValType::Obj,669			Self::Bool(_) => ValType::Bool,670			Self::Null => ValType::Null,671			Self::Func(..) => ValType::Func,672		}673	}674675	pub fn manifest(&self, format: impl ManifestFormat) -> Result<String> {676		fn manifest_dyn(val: &Val, manifest: &dyn ManifestFormat) -> Result<String> {677			manifest.manifest(val.clone())678		}679		manifest_dyn(self, &format)680	}681682	pub fn to_string(&self) -> Result<IStr> {683		Ok(match self {684			Self::Bool(true) => "true".into(),685			Self::Bool(false) => "false".into(),686			Self::Null => "null".into(),687			Self::Str(s) => s.clone().into_flat(),688			_ => self.manifest(ToStringFormat).map(IStr::from)?,689		})690	}691692	pub fn into_indexable(self) -> Result<IndexableVal> {693		Ok(match self {694			Self::Str(s) => IndexableVal::Str(s.into_flat()),695			Self::Arr(arr) => IndexableVal::Arr(arr),696			_ => bail!(ValueIsNotIndexable(self.value_type())),697		})698	}699700	pub fn function(function: impl Into<FuncVal>) -> Self {701		Self::Func(function.into())702	}703	pub fn string(string: impl Into<StrValue>) -> Self {704		Self::Str(string.into())705	}706	pub fn num(num: impl Into<NumValue>) -> Self {707		Self::Num(num.into())708	}709	pub fn try_num<V, E>(num: V) -> Result<Self, E>710	where711		NumValue: TryFrom<V, Error = E>,712	{713		Ok(Self::Num(num.try_into()?))714	}715	pub fn arr(a: impl ArrayLike) -> Self {716		Self::Arr(ArrValue::new(a))717	}718}719720impl From<IStr> for Val {721	fn from(value: IStr) -> Self {722		Self::string(value)723	}724}725impl From<String> for Val {726	fn from(value: String) -> Self {727		Self::string(value)728	}729}730impl From<&str> for Val {731	fn from(value: &str) -> Self {732		Self::string(value)733	}734}735impl From<ObjValue> for Val {736	fn from(value: ObjValue) -> Self {737		Self::Obj(value)738	}739}740741const fn is_function_like(val: &Val) -> bool {742	matches!(val, Val::Func(_))743}744745/// Native implementation of `std.primitiveEquals`746pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {747	Ok(match (val_a, val_b) {748		(Val::Bool(a), Val::Bool(b)) => a == b,749		(Val::Null, Val::Null) => true,750		(Val::Str(a), Val::Str(b)) => a == b,751		(Val::Num(a), Val::Num(b)) => (a.get() - b.get()).abs() <= f64::EPSILON,752		#[cfg(feature = "exp-bigint")]753		(Val::BigInt(a), Val::BigInt(b)) => a == b,754		(Val::Arr(_), Val::Arr(_)) => {755			bail!("primitiveEquals operates on primitive types, got array")756		}757		(Val::Obj(_), Val::Obj(_)) => {758			bail!("primitiveEquals operates on primitive types, got object")759		}760		(a, b) if is_function_like(a) && is_function_like(b) => {761			bail!("cannot test equality of functions")762		}763		(_, _) => false,764	})765}766767/// Native implementation of `std.equals`768pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {769	if val_a.value_type() != val_b.value_type() {770		return Ok(false);771	}772	match (val_a, val_b) {773		(Val::Arr(a), Val::Arr(b)) => {774			if ArrValue::ptr_eq(a, b) {775				return Ok(true);776			}777			if a.len() != b.len() {778				return Ok(false);779			}780			for (a, b) in a.iter().zip(b.iter()) {781				if !equals(&a?, &b?)? {782					return Ok(false);783				}784			}785			Ok(true)786		}787		(Val::Obj(a), Val::Obj(b)) => {788			if ObjValue::ptr_eq(a, b) {789				return Ok(true);790			}791			let fields = a.fields(792				#[cfg(feature = "exp-preserve-order")]793				false,794			);795			if fields796				!= b.fields(797					#[cfg(feature = "exp-preserve-order")]798					false,799				) {800				return Ok(false);801			}802			for field in fields {803				if !equals(804					&a.get(field.clone())?.expect("field exists"),805					&b.get(field)?.expect("field exists"),806				)? {807					return Ok(false);808				}809			}810			Ok(true)811		}812		(a, b) => Ok(primitive_equals(a, b)?),813	}814}