git.delta.rocks / jrsonnet / refs/commits / a85a2117c2f7

1use std::{2	cell::RefCell,3	fmt::{self, Debug, Display},4	mem::replace,5	rc::Rc,6};78use jrsonnet_gcmodule::{Cc, Trace};9use jrsonnet_interner::IStr;10use jrsonnet_types::ValType;1112pub use crate::arr::ArrValue;13use crate::{14	error::{Error, ErrorKind::*},15	function::FuncVal,16	gc::{GcHashMap, TraceBox},17	manifest::{ManifestFormat, ToStringFormat},18	tb, throw,19	typed::BoundedUsize,20	ObjValue, Result, Unbound, WeakObjValue,21};2223pub trait ThunkValue: Trace {24	type Output;25	fn get(self: Box<Self>) -> Result<Self::Output>;26}2728#[derive(Trace)]29enum ThunkInner<T: Trace> {30	Computed(T),31	Errored(Error),32	Waiting(TraceBox<dyn ThunkValue<Output = T>>),33	Pending,34}3536/// Lazily evaluated value37#[allow(clippy::module_name_repetitions)]38#[derive(Clone, Trace)]39pub struct Thunk<T: Trace>(Cc<RefCell<ThunkInner<T>>>);4041impl<T: Trace> Thunk<T> {42	pub fn evaluated(val: T) -> Self {43		Self(Cc::new(RefCell::new(ThunkInner::Computed(val))))44	}45	pub fn new(f: impl ThunkValue<Output = T> + 'static) -> Self {46		Self(Cc::new(RefCell::new(ThunkInner::Waiting(tb!(f)))))47	}48	pub fn errored(e: Error) -> Self {49		Self(Cc::new(RefCell::new(ThunkInner::Errored(e))))50	}51}5253impl<T> Thunk<T>54where55	T: Clone + Trace,56{57	pub fn force(&self) -> Result<()> {58		self.evaluate()?;59		Ok(())60	}6162	/// Evaluate thunk, or return cached value63	///64	/// # Errors65	///66	/// - Lazy value evaluation returned error67	/// - This method was called during inner value evaluation68	pub fn evaluate(&self) -> Result<T> {69		match &*self.0.borrow() {70			ThunkInner::Computed(v) => return Ok(v.clone()),71			ThunkInner::Errored(e) => return Err(e.clone()),72			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),73			ThunkInner::Waiting(..) => (),74		};75		let ThunkInner::Waiting(value) = replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)76		else {77			unreachable!();78		};79		let new_value = match value.0.get() {80			Ok(v) => v,81			Err(e) => {82				*self.0.borrow_mut() = ThunkInner::Errored(e.clone());83				return Err(e);84			}85		};86		*self.0.borrow_mut() = ThunkInner::Computed(new_value.clone());87		Ok(new_value)88	}89}9091type CacheKey = (Option<WeakObjValue>, Option<WeakObjValue>);9293#[derive(Trace, Clone)]94pub struct CachedUnbound<I, T>95where96	I: Unbound<Bound = T>,97	T: Trace,98{99	cache: Cc<RefCell<GcHashMap<CacheKey, T>>>,100	value: I,101}102impl<I: Unbound<Bound = T>, T: Trace> CachedUnbound<I, T> {103	pub fn new(value: I) -> Self {104		Self {105			cache: Cc::new(RefCell::new(GcHashMap::new())),106			value,107		}108	}109}110impl<I: Unbound<Bound = T>, T: Clone + Trace> Unbound for CachedUnbound<I, T> {111	type Bound = T;112	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<T> {113		let cache_key = (114			sup.as_ref().map(|s| s.clone().downgrade()),115			this.as_ref().map(|t| t.clone().downgrade()),116		);117		{118			if let Some(t) = self.cache.borrow().get(&cache_key) {119				return Ok(t.clone());120			}121		}122		let bound = self.value.bind(sup, this)?;123124		{125			let mut cache = self.cache.borrow_mut();126			cache.insert(cache_key, bound.clone());127		}128129		Ok(bound)130	}131}132133impl<T: Debug + Trace> Debug for Thunk<T> {134	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {135		write!(f, "Lazy")136	}137}138impl<T: Trace> PartialEq for Thunk<T> {139	fn eq(&self, other: &Self) -> bool {140		Cc::ptr_eq(&self.0, &other.0)141	}142}143144/// Represents a Jsonnet value, which can be sliced or indexed (string or array).145#[allow(clippy::module_name_repetitions)]146pub enum IndexableVal {147	/// String.148	Str(IStr),149	/// Array.150	Arr(ArrValue),151}152impl IndexableVal {153	pub fn to_array(self) -> ArrValue {154		match self {155			IndexableVal::Str(s) => ArrValue::chars(s.chars()),156			IndexableVal::Arr(arr) => arr,157		}158	}159	/// Slice the value.160	///161	/// # Implementation162	///163	/// For strings, will create a copy of specified interval.164	///165	/// For arrays, nothing will be copied on this call, instead [`ArrValue::Slice`] view will be returned.166	pub fn slice(167		self,168		index: Option<BoundedUsize<0, { i32::MAX as usize }>>,169		end: Option<BoundedUsize<0, { i32::MAX as usize }>>,170		step: Option<BoundedUsize<1, { i32::MAX as usize }>>,171	) -> Result<Self> {172		match &self {173			IndexableVal::Str(s) => {174				let index = index.as_deref().copied().unwrap_or(0);175				let end = end.as_deref().copied().unwrap_or(usize::MAX);176				let step = step.as_deref().copied().unwrap_or(1);177178				if index >= end {179					return Ok(Self::Str("".into()));180				}181182				Ok(Self::Str(183					(s.chars()184						.skip(index)185						.take(end - index)186						.step_by(step)187						.collect::<String>())188					.into(),189				))190			}191			IndexableVal::Arr(arr) => {192				let index = index.as_deref().copied().unwrap_or(0);193				let end = end.as_deref().copied().unwrap_or(usize::MAX).min(arr.len());194				let step = step.as_deref().copied().unwrap_or(1);195196				if index >= end {197					return Ok(Self::Arr(ArrValue::empty()));198				}199200				Ok(Self::Arr(201					arr.clone()202						.slice(Some(index), Some(end), Some(step))203						.expect("arguments checked"),204				))205			}206		}207	}208}209210#[derive(Debug, Clone, Trace)]211pub enum StrValue {212	Flat(IStr),213	Tree(Rc<(StrValue, StrValue, usize)>),214}215impl StrValue {216	pub fn concat(a: StrValue, b: StrValue) -> Self {217		// TODO: benchmark for an optimal value, currently just a arbitrary choice218		const STRING_EXTEND_THRESHOLD: usize = 100;219220		if a.is_empty() {221			b222		} else if b.is_empty() {223			a224		} else if a.len() + b.len() < STRING_EXTEND_THRESHOLD {225			Self::Flat(format!("{a}{b}").into())226		} else {227			let len = a.len() + b.len();228			Self::Tree(Rc::new((a, b, len)))229		}230	}231	pub fn into_flat(self) -> IStr {232		#[cold]233		fn write_buf(s: &StrValue, out: &mut String) {234			match s {235				StrValue::Flat(f) => out.push_str(f),236				StrValue::Tree(t) => {237					write_buf(&t.0, out);238					write_buf(&t.1, out);239				}240			}241		}242		match self {243			StrValue::Flat(f) => f,244			StrValue::Tree(_) => {245				let mut buf = String::with_capacity(self.len());246				write_buf(&self, &mut buf);247				buf.into()248			}249		}250	}251	pub fn len(&self) -> usize {252		match self {253			StrValue::Flat(v) => v.len(),254			StrValue::Tree(t) => t.2,255		}256	}257	pub fn is_empty(&self) -> bool {258		match self {259			Self::Flat(v) => v.is_empty(),260			// Can't create non-flat empty string261			Self::Tree(_) => false,262		}263	}264}265impl From<&str> for StrValue {266	fn from(value: &str) -> Self {267		Self::Flat(value.into())268	}269}270impl From<String> for StrValue {271	fn from(value: String) -> Self {272		Self::Flat(value.into())273	}274}275impl Display for StrValue {276	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {277		match self {278			StrValue::Flat(v) => write!(f, "{v}"),279			StrValue::Tree(t) => {280				write!(f, "{}", t.0)?;281				write!(f, "{}", t.1)282			}283		}284	}285}286impl PartialEq for StrValue {287	fn eq(&self, other: &Self) -> bool {288		let a = self.clone().into_flat();289		let b = other.clone().into_flat();290		a == b291	}292}293impl Eq for StrValue {}294impl PartialOrd for StrValue {295	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {296		let a = self.clone().into_flat();297		let b = other.clone().into_flat();298		Some(a.cmp(&b))299	}300}301impl Ord for StrValue {302	fn cmp(&self, other: &Self) -> std::cmp::Ordering {303		self.partial_cmp(other)304			.expect("partial_cmp always returns Some")305	}306}307308/// Represents any valid Jsonnet value.309#[derive(Debug, Clone, Trace)]310pub enum Val {311	/// Represents a Jsonnet boolean.312	Bool(bool),313	/// Represents a Jsonnet null value.314	Null,315	/// Represents a Jsonnet string.316	Str(StrValue),317	/// Represents a Jsonnet number.318	/// Should be finite, and not NaN319	/// This restriction isn't enforced by enum, as enum field can't be marked as private320	Num(f64),321	/// Experimental bigint322	#[cfg(feature = "exp-bigint")]323	BigInt(#[trace(skip)] Box<num_bigint::BigInt>),324	/// Represents a Jsonnet array.325	Arr(ArrValue),326	/// Represents a Jsonnet object.327	Obj(ObjValue),328	/// Represents a Jsonnet function.329	Func(FuncVal),330}331332#[cfg(target_pointer_width = "64")]333static_assertions::assert_eq_size!(Val, [u8; 24]);334335impl From<IndexableVal> for Val {336	fn from(v: IndexableVal) -> Self {337		match v {338			IndexableVal::Str(s) => Self::Str(StrValue::Flat(s)),339			IndexableVal::Arr(a) => Self::Arr(a),340		}341	}342}343344impl Val {345	pub const fn as_bool(&self) -> Option<bool> {346		match self {347			Self::Bool(v) => Some(*v),348			_ => None,349		}350	}351	pub const fn as_null(&self) -> Option<()> {352		match self {353			Self::Null => Some(()),354			_ => None,355		}356	}357	pub fn as_str(&self) -> Option<IStr> {358		match self {359			Self::Str(s) => Some(s.clone().into_flat()),360			_ => None,361		}362	}363	pub const fn as_num(&self) -> Option<f64> {364		match self {365			Self::Num(n) => Some(*n),366			_ => None,367		}368	}369	pub fn as_arr(&self) -> Option<ArrValue> {370		match self {371			Self::Arr(a) => Some(a.clone()),372			_ => None,373		}374	}375	pub fn as_obj(&self) -> Option<ObjValue> {376		match self {377			Self::Obj(o) => Some(o.clone()),378			_ => None,379		}380	}381	pub fn as_func(&self) -> Option<FuncVal> {382		match self {383			Self::Func(f) => Some(f.clone()),384			_ => None,385		}386	}387388	/// Creates `Val::Num` after checking for numeric overflow.389	/// As numbers are `f64`, we can just check for their finity.390	pub fn new_checked_num(num: f64) -> Result<Self> {391		if num.is_finite() {392			Ok(Self::Num(num))393		} else {394			throw!("overflow")395		}396	}397398	pub const fn value_type(&self) -> ValType {399		match self {400			Self::Str(..) => ValType::Str,401			Self::Num(..) => ValType::Num,402			#[cfg(feature = "exp-bigint")]403			Self::BigInt(..) => ValType::BigInt,404			Self::Arr(..) => ValType::Arr,405			Self::Obj(..) => ValType::Obj,406			Self::Bool(_) => ValType::Bool,407			Self::Null => ValType::Null,408			Self::Func(..) => ValType::Func,409		}410	}411412	pub fn manifest(&self, format: impl ManifestFormat) -> Result<String> {413		fn manifest_dyn(val: &Val, manifest: &dyn ManifestFormat) -> Result<String> {414			manifest.manifest(val.clone())415		}416		manifest_dyn(self, &format)417	}418419	pub fn to_string(&self) -> Result<IStr> {420		Ok(match self {421			Self::Bool(true) => "true".into(),422			Self::Bool(false) => "false".into(),423			Self::Null => "null".into(),424			Self::Str(s) => s.clone().into_flat(),425			_ => self.manifest(ToStringFormat).map(IStr::from)?,426		})427	}428429	pub fn into_indexable(self) -> Result<IndexableVal> {430		Ok(match self {431			Val::Str(s) => IndexableVal::Str(s.into_flat()),432			Val::Arr(arr) => IndexableVal::Arr(arr),433			_ => throw!(ValueIsNotIndexable(self.value_type())),434		})435	}436}437438const fn is_function_like(val: &Val) -> bool {439	matches!(val, Val::Func(_))440}441442/// Native implementation of `std.primitiveEquals`443pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {444	Ok(match (val_a, val_b) {445		(Val::Bool(a), Val::Bool(b)) => a == b,446		(Val::Null, Val::Null) => true,447		(Val::Str(a), Val::Str(b)) => a == b,448		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,449		#[cfg(feature = "exp-bigint")]450		(Val::BigInt(a), Val::BigInt(b)) => a == b,451		(Val::Arr(_), Val::Arr(_)) => {452			throw!("primitiveEquals operates on primitive types, got array")453		}454		(Val::Obj(_), Val::Obj(_)) => {455			throw!("primitiveEquals operates on primitive types, got object")456		}457		(a, b) if is_function_like(a) && is_function_like(b) => {458			throw!("cannot test equality of functions")459		}460		(_, _) => false,461	})462}463464/// Native implementation of `std.equals`465pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {466	if val_a.value_type() != val_b.value_type() {467		return Ok(false);468	}469	match (val_a, val_b) {470		(Val::Arr(a), Val::Arr(b)) => {471			if ArrValue::ptr_eq(a, b) {472				return Ok(true);473			}474			if a.len() != b.len() {475				return Ok(false);476			}477			for (a, b) in a.iter().zip(b.iter()) {478				if !equals(&a?, &b?)? {479					return Ok(false);480				}481			}482			Ok(true)483		}484		(Val::Obj(a), Val::Obj(b)) => {485			if ObjValue::ptr_eq(a, b) {486				return Ok(true);487			}488			let fields = a.fields(489				#[cfg(feature = "exp-preserve-order")]490				false,491			);492			if fields493				!= b.fields(494					#[cfg(feature = "exp-preserve-order")]495					false,496				) {497				return Ok(false);498			}499			for field in fields {500				if !equals(501					&a.get(field.clone())?.expect("field exists"),502					&b.get(field)?.expect("field exists"),503				)? {504					return Ok(false);505				}506			}507			Ok(true)508		}509		(a, b) => Ok(primitive_equals(a, b)?),510	}511}