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

1use std::{2	cell::RefCell,3	cmp::Ordering,4	fmt::{self, Debug, Display},5	mem::replace,6	num::NonZeroU32,7	ops::Deref,8	rc::Rc,9};1011use jrsonnet_gcmodule::{Acyclic, Cc, Trace, TraceBox};12use jrsonnet_interner::IStr;13pub use jrsonnet_macros::Thunk;14use jrsonnet_types::ValType;15use rustc_hash::FxHashMap;16use thiserror::Error;1718pub use crate::arr::{ArrValue, ArrayLike};19use crate::{20	bail,21	error::{Error, ErrorKind::*},22	function::FuncVal,23	gc::WithCapacityExt as _,24	manifest::{ManifestFormat, ToStringFormat},25	typed::BoundedUsize,26	ObjValue, Result, Unbound, WeakObjValue,27};2829pub trait ThunkValue: Trace {30	type Output;31	fn get(self: Box<Self>) -> Result<Self::Output>;32}3334#[derive(Trace)]35pub struct ThunkValueClosure<D: Trace, O: 'static> {36	env: D,37	// Carries no data, as it is not a real closure, all the38	// captured environment is stored in `env` field.39	#[trace(skip)]40	closure: fn(D) -> Result<O>,41}42impl<D: Trace, O: 'static> ThunkValueClosure<D, O> {43	pub fn new(env: D, closure: fn(D) -> Result<O>) -> Self {44		Self { env, closure }45	}46}47impl<D: Trace, O: 'static> ThunkValue for ThunkValueClosure<D, O> {48	type Output = O;4950	fn get(self: Box<Self>) -> Result<Self::Output> {51		(self.closure)(self.env)52	}53}5455#[derive(Trace)]56enum ThunkInner<T: Trace> {57	Computed(T),58	Errored(Error),59	Waiting(TraceBox<dyn ThunkValue<Output = T>>),60	Pending,61}6263/// Lazily evaluated value64#[allow(clippy::module_name_repetitions)]65#[derive(Clone, Trace)]66pub struct Thunk<T: Trace>(Cc<RefCell<ThunkInner<T>>>);6768impl<T: Trace> Thunk<T> {69	pub fn evaluated(val: T) -> Self {70		Self(Cc::new(RefCell::new(ThunkInner::Computed(val))))71	}72	pub fn new(f: impl ThunkValue<Output = T> + 'static) -> Self {73		Self(Cc::new(RefCell::new(ThunkInner::Waiting(TraceBox(74			Box::new(f),75		)))))76	}77	pub fn errored(e: Error) -> Self {78		Self(Cc::new(RefCell::new(ThunkInner::Errored(e))))79	}80	pub fn result(res: Result<T, Error>) -> Self {81		match res {82			Ok(o) => Self::evaluated(o),83			Err(e) => Self::errored(e),84		}85	}86}8788impl<T> Thunk<T>89where90	T: Clone + Trace,91{92	pub fn force(&self) -> Result<()> {93		self.evaluate()?;94		Ok(())95	}9697	/// Evaluate thunk, or return cached value98	///99	/// # Errors100	///101	/// - Lazy value evaluation returned error102	/// - This method was called during inner value evaluation103	pub fn evaluate(&self) -> Result<T> {104		match &*self.0.borrow() {105			ThunkInner::Computed(v) => return Ok(v.clone()),106			ThunkInner::Errored(e) => return Err(e.clone()),107			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),108			ThunkInner::Waiting(..) => (),109		};110		let ThunkInner::Waiting(value) = replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)111		else {112			unreachable!();113		};114		let new_value = match value.0.get() {115			Ok(v) => v,116			Err(e) => {117				*self.0.borrow_mut() = ThunkInner::Errored(e.clone());118				return Err(e);119			}120		};121		*self.0.borrow_mut() = ThunkInner::Computed(new_value.clone());122		Ok(new_value)123	}124}125126pub trait ThunkMapper<Input>: Trace {127	type Output;128	fn map(self, from: Input) -> Result<Self::Output>;129}130impl<Input> Thunk<Input>131where132	Input: Trace + Clone,133{134	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>135	where136		M: ThunkMapper<Input>,137		M::Output: Trace,138	{139		let inner = self;140		Thunk!(move || {141			let value = inner.evaluate()?;142			let mapped = mapper.map(value)?;143			Ok(mapped)144		})145	}146}147148impl<T: Trace> From<Result<T>> for Thunk<T> {149	fn from(value: Result<T>) -> Self {150		match value {151			Ok(o) => Self::evaluated(o),152			Err(e) => Self::errored(e),153		}154	}155}156impl<T, V: Trace> From<T> for Thunk<V>157where158	T: ThunkValue<Output = V>,159{160	fn from(value: T) -> Self {161		Self::new(value)162	}163}164165impl<T: Trace + Default> Default for Thunk<T> {166	fn default() -> Self {167		Self::evaluated(T::default())168	}169}170171type CacheKey = (Option<WeakObjValue>, Option<WeakObjValue>);172173#[derive(Trace, Clone)]174pub struct CachedUnbound<I, T>175where176	I: Unbound<Bound = T>,177	T: Trace,178{179	cache: Cc<RefCell<FxHashMap<CacheKey, T>>>,180	value: I,181}182impl<I: Unbound<Bound = T>, T: Trace> CachedUnbound<I, T> {183	pub fn new(value: I) -> Self {184		Self {185			cache: Cc::new(RefCell::new(FxHashMap::new())),186			value,187		}188	}189}190impl<I: Unbound<Bound = T>, T: Clone + Trace> Unbound for CachedUnbound<I, T> {191	type Bound = T;192	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<T> {193		let cache_key = (194			sup.as_ref().map(|s| s.clone().downgrade()),195			this.as_ref().map(|t| t.clone().downgrade()),196		);197		{198			if let Some(t) = self.cache.borrow().get(&cache_key) {199				return Ok(t.clone());200			}201		}202		let bound = self.value.bind(sup, this)?;203204		{205			let mut cache = self.cache.borrow_mut();206			cache.insert(cache_key, bound.clone());207		}208209		Ok(bound)210	}211}212213impl<T: Debug + Trace> Debug for Thunk<T> {214	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {215		write!(f, "Lazy")216	}217}218impl<T: Trace> PartialEq for Thunk<T> {219	fn eq(&self, other: &Self) -> bool {220		Cc::ptr_eq(&self.0, &other.0)221	}222}223224/// Represents a Jsonnet value, which can be sliced or indexed (string or array).225#[allow(clippy::module_name_repetitions)]226pub enum IndexableVal {227	/// String.228	Str(IStr),229	/// Array.230	Arr(ArrValue),231}232impl IndexableVal {233	pub fn is_empty(&self) -> bool {234		match self {235			Self::Str(s) => s.is_empty(),236			Self::Arr(s) => s.is_empty(),237		}238	}239240	pub fn to_array(self) -> ArrValue {241		match self {242			Self::Str(s) => ArrValue::chars(s.chars()),243			Self::Arr(arr) => arr,244		}245	}246	/// Slice the value.247	///248	/// # Implementation249	///250	/// For strings, will create a copy of specified interval.251	///252	/// For arrays, nothing will be copied on this call, instead [`ArrValue::Slice`] view will be returned.253	pub fn slice(254		self,255		index: Option<i32>,256		end: Option<i32>,257		step: Option<BoundedUsize<1, { i32::MAX as usize }>>,258	) -> Result<Self> {259		match &self {260			Self::Str(s) => {261				let mut computed_len = None;262				let mut get_len = || {263					computed_len.map_or_else(264						|| {265							let len = s.chars().count();266							let _ = computed_len.insert(len);267							len268						},269						|len| len,270					)271				};272				let mut get_idx = |pos: Option<i32>, default| {273					match pos {274						Some(v) if v < 0 => get_len().saturating_sub((-v) as usize),275						// No need to clamp, as iterator interface is used276						Some(v) => v as usize,277						None => default,278					}279				};280281				let index = get_idx(index, 0);282				let end = get_idx(end, usize::MAX);283				let step = step.as_deref().copied().unwrap_or(1);284285				if index >= end {286					return Ok(Self::Str("".into()));287				}288289				Ok(Self::Str(290					(s.chars()291						.skip(index)292						.take(end - index)293						.step_by(step)294						.collect::<String>())295					.into(),296				))297			}298			Self::Arr(arr) => Ok(Self::Arr(arr.clone().slice(299				index,300				end,301				step.map(|v| NonZeroU32::new(v.value() as u32).expect("bounded != 0")),302			))),303		}304	}305}306307#[derive(Debug, Clone, Acyclic)]308pub enum StrValue {309	Flat(IStr),310	Tree(Rc<(StrValue, StrValue, usize)>),311}312impl StrValue {313	pub fn concat(a: Self, b: Self) -> Self {314		// TODO: benchmark for an optimal value, currently just a arbitrary choice315		const STRING_EXTEND_THRESHOLD: usize = 100;316317		if a.is_empty() {318			b319		} else if b.is_empty() {320			a321		} else if a.len() + b.len() < STRING_EXTEND_THRESHOLD {322			Self::Flat(format!("{a}{b}").into())323		} else {324			let len = a.len() + b.len();325			Self::Tree(Rc::new((a, b, len)))326		}327	}328	pub fn into_flat(self) -> IStr {329		#[cold]330		fn write_buf(s: &StrValue, out: &mut String) {331			match s {332				StrValue::Flat(f) => out.push_str(f),333				StrValue::Tree(t) => {334					write_buf(&t.0, out);335					write_buf(&t.1, out);336				}337			}338		}339		match self {340			Self::Flat(f) => f,341			Self::Tree(_) => {342				let mut buf = String::with_capacity(self.len());343				write_buf(&self, &mut buf);344				buf.into()345			}346		}347	}348	pub fn len(&self) -> usize {349		match self {350			Self::Flat(v) => v.len(),351			Self::Tree(t) => t.2,352		}353	}354	pub fn is_empty(&self) -> bool {355		match self {356			Self::Flat(v) => v.is_empty(),357			// Can't create non-flat empty string358			Self::Tree(_) => false,359		}360	}361}362impl<T> From<T> for StrValue363where364	IStr: From<T>,365{366	fn from(value: T) -> Self {367		Self::Flat(IStr::from(value))368	}369}370impl Display for StrValue {371	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {372		match self {373			Self::Flat(v) => write!(f, "{v}"),374			Self::Tree(t) => {375				write!(f, "{}", t.0)?;376				write!(f, "{}", t.1)377			}378		}379	}380}381impl PartialEq for StrValue {382	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.383	#[allow(clippy::unconditional_recursion)]384	fn eq(&self, other: &Self) -> bool {385		let a = self.clone().into_flat();386		let b = other.clone().into_flat();387		a == b388	}389}390impl Eq for StrValue {}391impl PartialOrd for StrValue {392	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {393		Some(self.cmp(other))394	}395}396impl Ord for StrValue {397	fn cmp(&self, other: &Self) -> Ordering {398		let a = self.clone().into_flat();399		let b = other.clone().into_flat();400		a.cmp(&b)401	}402}403404/// Represents jsonnet number405/// Jsonnet numbers are finite f64, with NaNs disallowed406#[derive(Trace, Clone, Copy)]407#[repr(transparent)]408pub struct NumValue(f64);409impl NumValue {410	/// Creates a [`NumValue`], if value is finite and not NaN411	pub fn new(v: f64) -> Option<Self> {412		if !v.is_finite() {413			return None;414		}415		Some(Self(v))416	}417	#[inline]418	pub const fn get(&self) -> f64 {419		self.0420	}421}422impl PartialEq for NumValue {423	fn eq(&self, other: &Self) -> bool {424		self.0 == other.0425	}426}427impl Eq for NumValue {}428impl Ord for NumValue {429	#[inline]430	fn cmp(&self, other: &Self) -> Ordering {431		// Can't use `total_cmp`: its behavior for `-0` and `0`432		// is not following wanted.433		unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }434	}435}436impl PartialOrd for NumValue {437	#[inline]438	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {439		Some(self.cmp(other))440	}441}442impl Debug for NumValue {443	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {444		Debug::fmt(&self.0, f)445	}446}447impl Display for NumValue {448	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {449		Display::fmt(&self.0, f)450	}451}452impl Deref for NumValue {453	type Target = f64;454455	#[inline]456	fn deref(&self) -> &Self::Target {457		&self.0458	}459}460macro_rules! impl_num {461	($($ty:ty),+) => {$(462		impl From<$ty> for NumValue {463			#[inline]464			fn from(value: $ty) -> Self {465				Self(value.into())466			}467		}468	)+};469}470impl_num!(i8, u8, i16, u16, i32, u32);471472#[derive(Clone, Copy, Debug, Error, Trace)]473pub enum ConvertNumValueError {474	#[error("overflow")]475	Overflow,476	#[error("underflow")]477	Underflow,478	#[error("non-finite")]479	NonFinite,480}481impl From<ConvertNumValueError> for Error {482	fn from(e: ConvertNumValueError) -> Self {483		Self::new(e.into())484	}485}486487macro_rules! impl_try_num {488	($($ty:ty),+) => {$(489		impl TryFrom<$ty> for NumValue {490			type Error = ConvertNumValueError;491			#[inline]492			fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {493				use crate::typed::conversions::{MIN_SAFE_INTEGER, MAX_SAFE_INTEGER};494				let value = value as f64;495				if value < MIN_SAFE_INTEGER {496					return Err(ConvertNumValueError::Underflow)497				} else if value > MAX_SAFE_INTEGER {498					return Err(ConvertNumValueError::Overflow)499				}500				// Number is finite.501				Ok(Self(value))502			}503		}504	)+};505}506impl_try_num!(usize, isize, i64, u64);507508impl TryFrom<f64> for NumValue {509	type Error = ConvertNumValueError;510511	#[inline]512	fn try_from(value: f64) -> Result<Self, Self::Error> {513		Self::new(value).ok_or(ConvertNumValueError::NonFinite)514	}515}516impl TryFrom<f32> for NumValue {517	type Error = ConvertNumValueError;518519	#[inline]520	fn try_from(value: f32) -> Result<Self, Self::Error> {521		Self::new(f64::from(value)).ok_or(ConvertNumValueError::NonFinite)522	}523}524525/// Represents any valid Jsonnet value.526#[derive(Debug, Clone, Trace, Default)]527pub enum Val {528	/// Represents a Jsonnet boolean.529	Bool(bool),530	/// Represents a Jsonnet null value.531	#[default]532	Null,533	/// Represents a Jsonnet string.534	Str(StrValue),535	/// Represents a Jsonnet number.536	/// Should be finite, and not NaN537	/// This restriction isn't enforced by enum, as enum field can't be marked as private538	Num(NumValue),539	/// Experimental bigint540	#[cfg(feature = "exp-bigint")]541	BigInt(#[trace(skip)] Box<num_bigint::BigInt>),542	/// Represents a Jsonnet array.543	Arr(ArrValue),544	/// Represents a Jsonnet object.545	Obj(ObjValue),546	/// Represents a Jsonnet function.547	Func(FuncVal),548}549550#[cfg(target_pointer_width = "64")]551static_assertions::assert_eq_size!(Val, [u8; 24]);552553impl From<IndexableVal> for Val {554	fn from(v: IndexableVal) -> Self {555		match v {556			IndexableVal::Str(s) => Self::string(s),557			IndexableVal::Arr(a) => Self::Arr(a),558		}559	}560}561562impl Val {563	pub const fn as_bool(&self) -> Option<bool> {564		match self {565			Self::Bool(v) => Some(*v),566			_ => None,567		}568	}569	pub const fn as_null(&self) -> Option<()> {570		match self {571			Self::Null => Some(()),572			_ => None,573		}574	}575	pub fn as_str(&self) -> Option<IStr> {576		match self {577			Self::Str(s) => Some(s.clone().into_flat()),578			_ => None,579		}580	}581	pub const fn as_num(&self) -> Option<f64> {582		match self {583			Self::Num(n) => Some(n.get()),584			_ => None,585		}586	}587	#[cfg(feature = "exp-bigint")]588	pub fn as_bigint(&self) -> Option<num_bigint::BigInt> {589		match self {590			Self::BigInt(n) => Some(*n.clone()),591			_ => None,592		}593	}594	pub fn as_arr(&self) -> Option<ArrValue> {595		match self {596			Self::Arr(a) => Some(a.clone()),597			_ => None,598		}599	}600	pub fn as_obj(&self) -> Option<ObjValue> {601		match self {602			Self::Obj(o) => Some(o.clone()),603			_ => None,604		}605	}606	pub fn as_func(&self) -> Option<FuncVal> {607		match self {608			Self::Func(f) => Some(f.clone()),609			_ => None,610		}611	}612613	pub const fn value_type(&self) -> ValType {614		match self {615			Self::Str(..) => ValType::Str,616			Self::Num(..) => ValType::Num,617			#[cfg(feature = "exp-bigint")]618			Self::BigInt(..) => ValType::BigInt,619			Self::Arr(..) => ValType::Arr,620			Self::Obj(..) => ValType::Obj,621			Self::Bool(_) => ValType::Bool,622			Self::Null => ValType::Null,623			Self::Func(..) => ValType::Func,624		}625	}626627	pub fn manifest(&self, format: impl ManifestFormat) -> Result<String> {628		fn manifest_dyn(val: &Val, manifest: &dyn ManifestFormat) -> Result<String> {629			manifest.manifest(val.clone())630		}631		manifest_dyn(self, &format)632	}633634	pub fn to_string(&self) -> Result<IStr> {635		Ok(match self {636			Self::Bool(true) => "true".into(),637			Self::Bool(false) => "false".into(),638			Self::Null => "null".into(),639			Self::Str(s) => s.clone().into_flat(),640			_ => self.manifest(ToStringFormat).map(IStr::from)?,641		})642	}643644	pub fn into_indexable(self) -> Result<IndexableVal> {645		Ok(match self {646			Self::Str(s) => IndexableVal::Str(s.into_flat()),647			Self::Arr(arr) => IndexableVal::Arr(arr),648			_ => bail!(ValueIsNotIndexable(self.value_type())),649		})650	}651652	pub fn function(function: impl Into<FuncVal>) -> Self {653		Self::Func(function.into())654	}655	pub fn string(string: impl Into<StrValue>) -> Self {656		Self::Str(string.into())657	}658	pub fn num(num: impl Into<NumValue>) -> Self {659		Self::Num(num.into())660	}661	pub fn try_num<V, E>(num: V) -> Result<Self, E>662	where663		NumValue: TryFrom<V, Error = E>,664	{665		Ok(Self::Num(num.try_into()?))666	}667}668669impl From<IStr> for Val {670	fn from(value: IStr) -> Self {671		Self::string(value)672	}673}674impl From<String> for Val {675	fn from(value: String) -> Self {676		Self::string(value)677	}678}679impl From<&str> for Val {680	fn from(value: &str) -> Self {681		Self::string(value)682	}683}684impl From<ObjValue> for Val {685	fn from(value: ObjValue) -> Self {686		Self::Obj(value)687	}688}689690const fn is_function_like(val: &Val) -> bool {691	matches!(val, Val::Func(_))692}693694/// Native implementation of `std.primitiveEquals`695pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {696	Ok(match (val_a, val_b) {697		(Val::Bool(a), Val::Bool(b)) => a == b,698		(Val::Null, Val::Null) => true,699		(Val::Str(a), Val::Str(b)) => a == b,700		(Val::Num(a), Val::Num(b)) => (a.get() - b.get()).abs() <= f64::EPSILON,701		#[cfg(feature = "exp-bigint")]702		(Val::BigInt(a), Val::BigInt(b)) => a == b,703		(Val::Arr(_), Val::Arr(_)) => {704			bail!("primitiveEquals operates on primitive types, got array")705		}706		(Val::Obj(_), Val::Obj(_)) => {707			bail!("primitiveEquals operates on primitive types, got object")708		}709		(a, b) if is_function_like(a) && is_function_like(b) => {710			bail!("cannot test equality of functions")711		}712		(_, _) => false,713	})714}715716/// Native implementation of `std.equals`717pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {718	if val_a.value_type() != val_b.value_type() {719		return Ok(false);720	}721	match (val_a, val_b) {722		(Val::Arr(a), Val::Arr(b)) => {723			if ArrValue::ptr_eq(a, b) {724				return Ok(true);725			}726			if a.len() != b.len() {727				return Ok(false);728			}729			for (a, b) in a.iter().zip(b.iter()) {730				if !equals(&a?, &b?)? {731					return Ok(false);732				}733			}734			Ok(true)735		}736		(Val::Obj(a), Val::Obj(b)) => {737			if ObjValue::ptr_eq(a, b) {738				return Ok(true);739			}740			let fields = a.fields(741				#[cfg(feature = "exp-preserve-order")]742				false,743			);744			if fields745				!= b.fields(746					#[cfg(feature = "exp-preserve-order")]747					false,748				) {749				return Ok(false);750			}751			for field in fields {752				if !equals(753					&a.get(field.clone())?.expect("field exists"),754					&b.get(field)?.expect("field exists"),755				)? {756					return Ok(false);757				}758			}759			Ok(true)760		}761		(a, b) => Ok(primitive_equals(a, b)?),762	}763}