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

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::{cc_dyn, Acyclic, Cc, Trace};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	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	ObjValue, Result, SupThis, Unbound, WeakSupThis,28};2930pub trait ThunkValue: Trace {31	type Output;32	fn get(&self) -> Result<Self::Output>;33}3435#[derive(Trace)]36enum MemoizedClusureThunkInner<D: Trace, T: Trace> {37	Computed(T),38	Errored(Error),39	Waiting {40		env: D,41		// Carries no data, as it is not a real closure, all the42		// captured environment is stored in `env` field.43		#[trace(skip)]44		closure: fn(D) -> Result<T>,45	},46	Pending,47}48#[derive(Trace)]49pub struct MemoizedClosureThunk<D: Trace, T: Trace>(RefCell<MemoizedClusureThunkInner<D, T>>);50impl<D: Trace, T: Trace> MemoizedClosureThunk<D, T> {51	pub fn new(env: D, closure: fn(D) -> Result<T>) -> Self {52		Self(RefCell::new(MemoizedClusureThunkInner::Waiting {53			env,54			closure,55		}))56	}57}5859impl<D: Trace, T: Trace + Clone> ThunkValue for MemoizedClosureThunk<D, T> {60	type Output = T;6162	fn get(&self) -> Result<Self::Output> {63		match &*self.0.borrow() {64			MemoizedClusureThunkInner::Computed(v) => return Ok(v.clone()),65			MemoizedClusureThunkInner::Errored(e) => return Err(e.clone()),66			MemoizedClusureThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),67			MemoizedClusureThunkInner::Waiting { .. } => (),68		};69		let MemoizedClusureThunkInner::Waiting { env, closure } = replace(70			&mut *self.0.borrow_mut(),71			MemoizedClusureThunkInner::Pending,72		) else {73			unreachable!();74		};75		let new_value = match closure(env) {76			Ok(v) => v,77			Err(e) => {78				*self.0.borrow_mut() = MemoizedClusureThunkInner::Errored(e.clone());79				return Err(e);80			}81		};82		*self.0.borrow_mut() = MemoizedClusureThunkInner::Computed(new_value.clone());83		Ok(new_value)84	}85}8687cc_dyn!(88	/// Lazily evaluated value89	#[derive(Clone)] Thunk<V: Trace>,90	ThunkValue<Output = V>,91	pub fn new() {...}92);9394impl<T: Trace> Thunk<T> {95	pub fn evaluated(val: T) -> Self96	where97		T: Clone,98	{99		#[derive(Trace)]100		struct EvaluatedThunk<T: Trace>(T);101		impl<T> ThunkValue for EvaluatedThunk<T>102		where103			T: Clone + Trace,104		{105			type Output = T;106107			fn get(&self) -> Result<Self::Output> {108				Ok(self.0.clone())109			}110		}111		Self::new(EvaluatedThunk(val))112	}113	pub fn errored(e: Error) -> Self {114		#[derive(Trace)]115		struct ErroredThunk<T: Trace>(Error, PhantomData<T>);116		impl<T> ThunkValue for ErroredThunk<T>117		where118			T: Trace,119		{120			type Output = T;121122			fn get(&self) -> Result<Self::Output> {123				Err(self.0.clone())124			}125		}126		Self::new(ErroredThunk(e, PhantomData))127	}128	pub fn result(res: Result<T, Error>) -> Self129	where130		T: Clone,131	{132		match res {133			Ok(o) => Self::evaluated(o),134			Err(e) => Self::errored(e),135		}136	}137}138139impl<T> Thunk<T>140where141	T: Clone + Trace,142{143	pub fn force(&self) -> Result<()> {144		self.evaluate()?;145		Ok(())146	}147148	/// Evaluate thunk, or return cached value149	///150	/// # Errors151	///152	/// - Lazy value evaluation returned error153	/// - This method was called during inner value evaluation154	pub fn evaluate(&self) -> Result<T> {155		self.0.get()156	}157}158159pub trait ThunkMapper<Input>: Trace {160	type Output;161	fn map(self, from: Input) -> Result<Self::Output>;162}163impl<Input> Thunk<Input>164where165	Input: Trace + Clone,166{167	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>168	where169		M: ThunkMapper<Input>,170		M::Output: Trace + Clone,171	{172		let inner = self;173		Thunk!(move || {174			let value = inner.evaluate()?;175			let mapped = mapper.map(value)?;176			Ok(mapped)177		})178	}179}180181impl<T: Trace + Clone> From<Result<T>> for Thunk<T> {182	fn from(value: Result<T>) -> Self {183		match value {184			Ok(o) => Self::evaluated(o),185			Err(e) => Self::errored(e),186		}187	}188}189impl<T, V: Trace> From<T> for Thunk<V>190where191	T: ThunkValue<Output = V>,192{193	fn from(value: T) -> Self {194		Self::new(value)195	}196}197198impl<T: Trace + Default + Clone> Default for Thunk<T> {199	fn default() -> Self {200		Self::evaluated(T::default())201	}202}203204#[derive(Trace, Clone)]205pub struct CachedUnbound<I, T>206where207	I: Unbound<Bound = T>,208	T: Trace,209{210	cache: Cc<RefCell<FxHashMap<WeakSupThis, T>>>,211	value: I,212}213impl<I: Unbound<Bound = T>, T: Trace> CachedUnbound<I, T> {214	pub fn new(value: I) -> Self {215		Self {216			cache: Cc::new(RefCell::new(FxHashMap::new())),217			value,218		}219	}220}221impl<I: Unbound<Bound = T>, T: Clone + Trace> Unbound for CachedUnbound<I, T> {222	type Bound = T;223	fn bind(&self, sup_this: SupThis) -> Result<T> {224		let cache_key = sup_this.clone().downgrade();225		{226			if let Some(t) = self.cache.borrow().get(&cache_key) {227				return Ok(t.clone());228			}229		}230		let bound = self.value.bind(sup_this)?;231232		{233			let mut cache = self.cache.borrow_mut();234			cache.insert(cache_key, bound.clone());235		}236237		Ok(bound)238	}239}240241impl<T: Debug + Trace> Debug for Thunk<T> {242	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {243		write!(f, "Lazy")244	}245}246impl<T: Trace> PartialEq for Thunk<T> {247	fn eq(&self, other: &Self) -> bool {248		Cc::ptr_eq(&self.0, &other.0)249	}250}251252/// Represents a Jsonnet value, which can be sliced or indexed (string or array).253#[allow(clippy::module_name_repetitions)]254pub enum IndexableVal {255	/// String.256	Str(IStr),257	/// Array.258	Arr(ArrValue),259}260impl IndexableVal {261	pub fn is_empty(&self) -> bool {262		match self {263			Self::Str(s) => s.is_empty(),264			Self::Arr(s) => s.is_empty(),265		}266	}267268	pub fn to_array(self) -> ArrValue {269		match self {270			Self::Str(s) => ArrValue::chars(s.chars()),271			Self::Arr(arr) => arr,272		}273	}274	/// Slice the value.275	///276	/// # Implementation277	///278	/// For strings, will create a copy of specified interval.279	///280	/// For arrays, nothing will be copied on this call, instead [`ArrValue::Slice`] view will be returned.281	pub fn slice(282		self,283		index: Option<i32>,284		end: Option<i32>,285		step: Option<BoundedUsize<1, { i32::MAX as usize }>>,286	) -> Result<Self> {287		match &self {288			Self::Str(s) => {289				let mut computed_len = None;290				let mut get_len = || {291					computed_len.map_or_else(292						|| {293							let len = s.chars().count();294							let _ = computed_len.insert(len);295							len296						},297						|len| len,298					)299				};300				let mut get_idx = |pos: Option<i32>, default| {301					match pos {302						Some(v) if v < 0 => get_len().saturating_sub((-v) as usize),303						// No need to clamp, as iterator interface is used304						Some(v) => v as usize,305						None => default,306					}307				};308309				let index = get_idx(index, 0);310				let end = get_idx(end, usize::MAX);311				let step = step.as_deref().copied().unwrap_or(1);312313				if index >= end {314					return Ok(Self::Str("".into()));315				}316317				Ok(Self::Str(318					(s.chars()319						.skip(index)320						.take(end - index)321						.step_by(step)322						.collect::<String>())323					.into(),324				))325			}326			Self::Arr(arr) => Ok(Self::Arr(arr.clone().slice(327				index,328				end,329				step.map(|v| NonZeroU32::new(v.value() as u32).expect("bounded != 0")),330			))),331		}332	}333}334335#[derive(Debug, Clone, Acyclic)]336pub enum StrValue {337	Flat(IStr),338	Tree(Rc<(StrValue, StrValue, usize)>),339}340impl StrValue {341	pub fn concat(a: Self, b: Self) -> Self {342		// TODO: benchmark for an optimal value, currently just a arbitrary choice343		const STRING_EXTEND_THRESHOLD: usize = 100;344345		if a.is_empty() {346			b347		} else if b.is_empty() {348			a349		} else if a.len() + b.len() < STRING_EXTEND_THRESHOLD {350			Self::Flat(format!("{a}{b}").into())351		} else {352			let len = a.len() + b.len();353			Self::Tree(Rc::new((a, b, len)))354		}355	}356	pub fn into_flat(self) -> IStr {357		#[cold]358		fn write_buf(s: &StrValue, out: &mut String) {359			match s {360				StrValue::Flat(f) => out.push_str(f),361				StrValue::Tree(t) => {362					write_buf(&t.0, out);363					write_buf(&t.1, out);364				}365			}366		}367		match self {368			Self::Flat(f) => f,369			Self::Tree(_) => {370				let mut buf = String::with_capacity(self.len());371				write_buf(&self, &mut buf);372				buf.into()373			}374		}375	}376	pub fn len(&self) -> usize {377		match self {378			Self::Flat(v) => v.len(),379			Self::Tree(t) => t.2,380		}381	}382	pub fn is_empty(&self) -> bool {383		match self {384			Self::Flat(v) => v.is_empty(),385			// Can't create non-flat empty string386			Self::Tree(_) => false,387		}388	}389}390impl<T> From<T> for StrValue391where392	IStr: From<T>,393{394	fn from(value: T) -> Self {395		Self::Flat(IStr::from(value))396	}397}398impl Display for StrValue {399	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {400		match self {401			Self::Flat(v) => write!(f, "{v}"),402			Self::Tree(t) => {403				write!(f, "{}", t.0)?;404				write!(f, "{}", t.1)405			}406		}407	}408}409impl PartialEq for StrValue {410	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.411	#[allow(clippy::unconditional_recursion)]412	fn eq(&self, other: &Self) -> bool {413		let a = self.clone().into_flat();414		let b = other.clone().into_flat();415		a == b416	}417}418impl Eq for StrValue {}419impl PartialOrd for StrValue {420	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {421		Some(self.cmp(other))422	}423}424impl Ord for StrValue {425	fn cmp(&self, other: &Self) -> Ordering {426		let a = self.clone().into_flat();427		let b = other.clone().into_flat();428		a.cmp(&b)429	}430}431432/// Represents jsonnet number433/// Jsonnet numbers are finite f64, with NaNs disallowed434#[derive(Trace, Clone, Copy)]435#[repr(transparent)]436pub struct NumValue(f64);437impl NumValue {438	/// Creates a [`NumValue`], if value is finite and not NaN439	pub fn new(v: f64) -> Option<Self> {440		if !v.is_finite() {441			return None;442		}443		Some(Self(v))444	}445	#[inline]446	pub const fn get(&self) -> f64 {447		self.0448	}449	pub(crate) fn truncate_for_bitwise(&self) -> Result<i64> {450		if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {451			bail!("numberic value outside of safe integer range for bitwise operation");452		}453		Ok(self.0 as i64)454	}455}456impl PartialEq for NumValue {457	fn eq(&self, other: &Self) -> bool {458		self.0 == other.0459	}460}461impl Eq for NumValue {}462impl Ord for NumValue {463	#[inline]464	fn cmp(&self, other: &Self) -> Ordering {465		// Can't use `total_cmp`: its behavior for `-0` and `0`466		// is not following wanted.467		unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }468	}469}470impl PartialOrd for NumValue {471	#[inline]472	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {473		Some(self.cmp(other))474	}475}476impl Debug for NumValue {477	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {478		Debug::fmt(&self.0, f)479	}480}481impl Display for NumValue {482	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {483		Display::fmt(&self.0, f)484	}485}486impl Deref for NumValue {487	type Target = f64;488489	#[inline]490	fn deref(&self) -> &Self::Target {491		&self.0492	}493}494macro_rules! impl_num {495	($($ty:ty),+) => {$(496		impl From<$ty> for NumValue {497			#[inline]498			fn from(value: $ty) -> Self {499				Self(value.into())500			}501		}502	)+};503}504impl_num!(i8, u8, i16, u16, i32, u32);505506#[derive(Clone, Copy, Debug, Error, Trace)]507pub enum ConvertNumValueError {508	#[error("overflow")]509	Overflow,510	#[error("underflow")]511	Underflow,512	#[error("non-finite")]513	NonFinite,514}515impl From<ConvertNumValueError> for Error {516	fn from(e: ConvertNumValueError) -> Self {517		Self::new(e.into())518	}519}520521macro_rules! impl_try_num {522	($($ty:ty),+) => {$(523		impl TryFrom<$ty> for NumValue {524			type Error = ConvertNumValueError;525			#[inline]526			fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {527				let value = value as f64;528				if value < MIN_SAFE_INTEGER {529					return Err(ConvertNumValueError::Underflow)530				} else if value > MAX_SAFE_INTEGER {531					return Err(ConvertNumValueError::Overflow)532				}533				// Number is finite.534				Ok(Self(value))535			}536		}537	)+};538}539impl_try_num!(usize, isize, i64, u64);540541impl TryFrom<f64> for NumValue {542	type Error = ConvertNumValueError;543544	#[inline]545	fn try_from(value: f64) -> Result<Self, Self::Error> {546		Self::new(value).ok_or(ConvertNumValueError::NonFinite)547	}548}549impl TryFrom<f32> for NumValue {550	type Error = ConvertNumValueError;551552	#[inline]553	fn try_from(value: f32) -> Result<Self, Self::Error> {554		Self::new(f64::from(value)).ok_or(ConvertNumValueError::NonFinite)555	}556}557558/// Represents any valid Jsonnet value.559#[derive(Debug, Clone, Trace, Default)]560pub enum Val {561	/// Represents a Jsonnet boolean.562	Bool(bool),563	/// Represents a Jsonnet null value.564	#[default]565	Null,566	/// Represents a Jsonnet string.567	Str(StrValue),568	/// Represents a Jsonnet number.569	/// Should be finite, and not NaN570	/// This restriction isn't enforced by enum, as enum field can't be marked as private571	Num(NumValue),572	/// Experimental bigint573	#[cfg(feature = "exp-bigint")]574	BigInt(#[trace(skip)] Box<num_bigint::BigInt>),575	/// Represents a Jsonnet array.576	Arr(ArrValue),577	/// Represents a Jsonnet object.578	Obj(ObjValue),579	/// Represents a Jsonnet function.580	Func(FuncVal),581}582583#[cfg(target_pointer_width = "64")]584static_assertions::assert_eq_size!(Val, [u8; 24]);585586impl From<IndexableVal> for Val {587	fn from(v: IndexableVal) -> Self {588		match v {589			IndexableVal::Str(s) => Self::string(s),590			IndexableVal::Arr(a) => Self::Arr(a),591		}592	}593}594595impl Val {596	pub const fn as_bool(&self) -> Option<bool> {597		match self {598			Self::Bool(v) => Some(*v),599			_ => None,600		}601	}602	pub const fn as_null(&self) -> Option<()> {603		match self {604			Self::Null => Some(()),605			_ => None,606		}607	}608	pub fn as_str(&self) -> Option<IStr> {609		match self {610			Self::Str(s) => Some(s.clone().into_flat()),611			_ => None,612		}613	}614	pub const fn as_num(&self) -> Option<f64> {615		match self {616			Self::Num(n) => Some(n.get()),617			_ => None,618		}619	}620	#[cfg(feature = "exp-bigint")]621	pub fn as_bigint(&self) -> Option<num_bigint::BigInt> {622		match self {623			Self::BigInt(n) => Some(*n.clone()),624			_ => None,625		}626	}627	pub fn as_arr(&self) -> Option<ArrValue> {628		match self {629			Self::Arr(a) => Some(a.clone()),630			_ => None,631		}632	}633	pub fn as_obj(&self) -> Option<ObjValue> {634		match self {635			Self::Obj(o) => Some(o.clone()),636			_ => None,637		}638	}639	pub fn as_func(&self) -> Option<FuncVal> {640		match self {641			Self::Func(f) => Some(f.clone()),642			_ => None,643		}644	}645646	pub const fn value_type(&self) -> ValType {647		match self {648			Self::Str(..) => ValType::Str,649			Self::Num(..) => ValType::Num,650			#[cfg(feature = "exp-bigint")]651			Self::BigInt(..) => ValType::BigInt,652			Self::Arr(..) => ValType::Arr,653			Self::Obj(..) => ValType::Obj,654			Self::Bool(_) => ValType::Bool,655			Self::Null => ValType::Null,656			Self::Func(..) => ValType::Func,657		}658	}659660	pub fn manifest(&self, format: impl ManifestFormat) -> Result<String> {661		fn manifest_dyn(val: &Val, manifest: &dyn ManifestFormat) -> Result<String> {662			manifest.manifest(val.clone())663		}664		manifest_dyn(self, &format)665	}666667	pub fn to_string(&self) -> Result<IStr> {668		Ok(match self {669			Self::Bool(true) => "true".into(),670			Self::Bool(false) => "false".into(),671			Self::Null => "null".into(),672			Self::Str(s) => s.clone().into_flat(),673			_ => self.manifest(ToStringFormat).map(IStr::from)?,674		})675	}676677	pub fn into_indexable(self) -> Result<IndexableVal> {678		Ok(match self {679			Self::Str(s) => IndexableVal::Str(s.into_flat()),680			Self::Arr(arr) => IndexableVal::Arr(arr),681			_ => bail!(ValueIsNotIndexable(self.value_type())),682		})683	}684685	pub fn function(function: impl Into<FuncVal>) -> Self {686		Self::Func(function.into())687	}688	pub fn string(string: impl Into<StrValue>) -> Self {689		Self::Str(string.into())690	}691	pub fn num(num: impl Into<NumValue>) -> Self {692		Self::Num(num.into())693	}694	pub fn try_num<V, E>(num: V) -> Result<Self, E>695	where696		NumValue: TryFrom<V, Error = E>,697	{698		Ok(Self::Num(num.try_into()?))699	}700}701702impl From<IStr> for Val {703	fn from(value: IStr) -> Self {704		Self::string(value)705	}706}707impl From<String> for Val {708	fn from(value: String) -> Self {709		Self::string(value)710	}711}712impl From<&str> for Val {713	fn from(value: &str) -> Self {714		Self::string(value)715	}716}717impl From<ObjValue> for Val {718	fn from(value: ObjValue) -> Self {719		Self::Obj(value)720	}721}722723const fn is_function_like(val: &Val) -> bool {724	matches!(val, Val::Func(_))725}726727/// Native implementation of `std.primitiveEquals`728pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {729	Ok(match (val_a, val_b) {730		(Val::Bool(a), Val::Bool(b)) => a == b,731		(Val::Null, Val::Null) => true,732		(Val::Str(a), Val::Str(b)) => a == b,733		(Val::Num(a), Val::Num(b)) => (a.get() - b.get()).abs() <= f64::EPSILON,734		#[cfg(feature = "exp-bigint")]735		(Val::BigInt(a), Val::BigInt(b)) => a == b,736		(Val::Arr(_), Val::Arr(_)) => {737			bail!("primitiveEquals operates on primitive types, got array")738		}739		(Val::Obj(_), Val::Obj(_)) => {740			bail!("primitiveEquals operates on primitive types, got object")741		}742		(a, b) if is_function_like(a) && is_function_like(b) => {743			bail!("cannot test equality of functions")744		}745		(_, _) => false,746	})747}748749/// Native implementation of `std.equals`750pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {751	if val_a.value_type() != val_b.value_type() {752		return Ok(false);753	}754	match (val_a, val_b) {755		(Val::Arr(a), Val::Arr(b)) => {756			if ArrValue::ptr_eq(a, b) {757				return Ok(true);758			}759			if a.len() != b.len() {760				return Ok(false);761			}762			for (a, b) in a.iter().zip(b.iter()) {763				if !equals(&a?, &b?)? {764					return Ok(false);765				}766			}767			Ok(true)768		}769		(Val::Obj(a), Val::Obj(b)) => {770			if ObjValue::ptr_eq(a, b) {771				return Ok(true);772			}773			let fields = a.fields(774				#[cfg(feature = "exp-preserve-order")]775				false,776			);777			if fields778				!= b.fields(779					#[cfg(feature = "exp-preserve-order")]780					false,781				) {782				return Ok(false);783			}784			for field in fields {785				if !equals(786					&a.get(field.clone())?.expect("field exists"),787					&b.get(field)?.expect("field exists"),788				)? {789					return Ok(false);790				}791			}792			Ok(true)793		}794		(a, b) => Ok(primitive_equals(a, b)?),795	}796}