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

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, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER},26	ObjValue, Result, SupThis, Unbound, WeakSupThis,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}170171#[derive(Trace, Clone)]172pub struct CachedUnbound<I, T>173where174	I: Unbound<Bound = T>,175	T: Trace,176{177	cache: Cc<RefCell<FxHashMap<WeakSupThis, T>>>,178	value: I,179}180impl<I: Unbound<Bound = T>, T: Trace> CachedUnbound<I, T> {181	pub fn new(value: I) -> Self {182		Self {183			cache: Cc::new(RefCell::new(FxHashMap::new())),184			value,185		}186	}187}188impl<I: Unbound<Bound = T>, T: Clone + Trace> Unbound for CachedUnbound<I, T> {189	type Bound = T;190	fn bind(&self, sup_this: SupThis) -> Result<T> {191		let cache_key = sup_this.clone().downgrade();192		{193			if let Some(t) = self.cache.borrow().get(&cache_key) {194				return Ok(t.clone());195			}196		}197		let bound = self.value.bind(sup_this)?;198199		{200			let mut cache = self.cache.borrow_mut();201			cache.insert(cache_key, bound.clone());202		}203204		Ok(bound)205	}206}207208impl<T: Debug + Trace> Debug for Thunk<T> {209	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {210		write!(f, "Lazy")211	}212}213impl<T: Trace> PartialEq for Thunk<T> {214	fn eq(&self, other: &Self) -> bool {215		Cc::ptr_eq(&self.0, &other.0)216	}217}218219/// Represents a Jsonnet value, which can be sliced or indexed (string or array).220#[allow(clippy::module_name_repetitions)]221pub enum IndexableVal {222	/// String.223	Str(IStr),224	/// Array.225	Arr(ArrValue),226}227impl IndexableVal {228	pub fn is_empty(&self) -> bool {229		match self {230			Self::Str(s) => s.is_empty(),231			Self::Arr(s) => s.is_empty(),232		}233	}234235	pub fn to_array(self) -> ArrValue {236		match self {237			Self::Str(s) => ArrValue::chars(s.chars()),238			Self::Arr(arr) => arr,239		}240	}241	/// Slice the value.242	///243	/// # Implementation244	///245	/// For strings, will create a copy of specified interval.246	///247	/// For arrays, nothing will be copied on this call, instead [`ArrValue::Slice`] view will be returned.248	pub fn slice(249		self,250		index: Option<i32>,251		end: Option<i32>,252		step: Option<BoundedUsize<1, { i32::MAX as usize }>>,253	) -> Result<Self> {254		match &self {255			Self::Str(s) => {256				let mut computed_len = None;257				let mut get_len = || {258					computed_len.map_or_else(259						|| {260							let len = s.chars().count();261							let _ = computed_len.insert(len);262							len263						},264						|len| len,265					)266				};267				let mut get_idx = |pos: Option<i32>, default| {268					match pos {269						Some(v) if v < 0 => get_len().saturating_sub((-v) as usize),270						// No need to clamp, as iterator interface is used271						Some(v) => v as usize,272						None => default,273					}274				};275276				let index = get_idx(index, 0);277				let end = get_idx(end, usize::MAX);278				let step = step.as_deref().copied().unwrap_or(1);279280				if index >= end {281					return Ok(Self::Str("".into()));282				}283284				Ok(Self::Str(285					(s.chars()286						.skip(index)287						.take(end - index)288						.step_by(step)289						.collect::<String>())290					.into(),291				))292			}293			Self::Arr(arr) => Ok(Self::Arr(arr.clone().slice(294				index,295				end,296				step.map(|v| NonZeroU32::new(v.value() as u32).expect("bounded != 0")),297			))),298		}299	}300}301302#[derive(Debug, Clone, Acyclic)]303pub enum StrValue {304	Flat(IStr),305	Tree(Rc<(StrValue, StrValue, usize)>),306}307impl StrValue {308	pub fn concat(a: Self, b: Self) -> Self {309		// TODO: benchmark for an optimal value, currently just a arbitrary choice310		const STRING_EXTEND_THRESHOLD: usize = 100;311312		if a.is_empty() {313			b314		} else if b.is_empty() {315			a316		} else if a.len() + b.len() < STRING_EXTEND_THRESHOLD {317			Self::Flat(format!("{a}{b}").into())318		} else {319			let len = a.len() + b.len();320			Self::Tree(Rc::new((a, b, len)))321		}322	}323	pub fn into_flat(self) -> IStr {324		#[cold]325		fn write_buf(s: &StrValue, out: &mut String) {326			match s {327				StrValue::Flat(f) => out.push_str(f),328				StrValue::Tree(t) => {329					write_buf(&t.0, out);330					write_buf(&t.1, out);331				}332			}333		}334		match self {335			Self::Flat(f) => f,336			Self::Tree(_) => {337				let mut buf = String::with_capacity(self.len());338				write_buf(&self, &mut buf);339				buf.into()340			}341		}342	}343	pub fn len(&self) -> usize {344		match self {345			Self::Flat(v) => v.len(),346			Self::Tree(t) => t.2,347		}348	}349	pub fn is_empty(&self) -> bool {350		match self {351			Self::Flat(v) => v.is_empty(),352			// Can't create non-flat empty string353			Self::Tree(_) => false,354		}355	}356}357impl<T> From<T> for StrValue358where359	IStr: From<T>,360{361	fn from(value: T) -> Self {362		Self::Flat(IStr::from(value))363	}364}365impl Display for StrValue {366	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {367		match self {368			Self::Flat(v) => write!(f, "{v}"),369			Self::Tree(t) => {370				write!(f, "{}", t.0)?;371				write!(f, "{}", t.1)372			}373		}374	}375}376impl PartialEq for StrValue {377	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.378	#[allow(clippy::unconditional_recursion)]379	fn eq(&self, other: &Self) -> bool {380		let a = self.clone().into_flat();381		let b = other.clone().into_flat();382		a == b383	}384}385impl Eq for StrValue {}386impl PartialOrd for StrValue {387	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {388		Some(self.cmp(other))389	}390}391impl Ord for StrValue {392	fn cmp(&self, other: &Self) -> Ordering {393		let a = self.clone().into_flat();394		let b = other.clone().into_flat();395		a.cmp(&b)396	}397}398399/// Represents jsonnet number400/// Jsonnet numbers are finite f64, with NaNs disallowed401#[derive(Trace, Clone, Copy)]402#[repr(transparent)]403pub struct NumValue(f64);404impl NumValue {405	/// Creates a [`NumValue`], if value is finite and not NaN406	pub fn new(v: f64) -> Option<Self> {407		if !v.is_finite() {408			return None;409		}410		Some(Self(v))411	}412	#[inline]413	pub const fn get(&self) -> f64 {414		self.0415	}416	pub(crate) fn truncate_for_bitwise(&self) -> Result<i64> {417		if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {418			bail!("numberic value outside of safe integer range for bitwise operation");419		}420		Ok(self.0 as i64)421	}422}423impl PartialEq for NumValue {424	fn eq(&self, other: &Self) -> bool {425		self.0 == other.0426	}427}428impl Eq for NumValue {}429impl Ord for NumValue {430	#[inline]431	fn cmp(&self, other: &Self) -> Ordering {432		// Can't use `total_cmp`: its behavior for `-0` and `0`433		// is not following wanted.434		unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }435	}436}437impl PartialOrd for NumValue {438	#[inline]439	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {440		Some(self.cmp(other))441	}442}443impl Debug for NumValue {444	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {445		Debug::fmt(&self.0, f)446	}447}448impl Display for NumValue {449	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {450		Display::fmt(&self.0, f)451	}452}453impl Deref for NumValue {454	type Target = f64;455456	#[inline]457	fn deref(&self) -> &Self::Target {458		&self.0459	}460}461macro_rules! impl_num {462	($($ty:ty),+) => {$(463		impl From<$ty> for NumValue {464			#[inline]465			fn from(value: $ty) -> Self {466				Self(value.into())467			}468		}469	)+};470}471impl_num!(i8, u8, i16, u16, i32, u32);472473#[derive(Clone, Copy, Debug, Error, Trace)]474pub enum ConvertNumValueError {475	#[error("overflow")]476	Overflow,477	#[error("underflow")]478	Underflow,479	#[error("non-finite")]480	NonFinite,481}482impl From<ConvertNumValueError> for Error {483	fn from(e: ConvertNumValueError) -> Self {484		Self::new(e.into())485	}486}487488macro_rules! impl_try_num {489	($($ty:ty),+) => {$(490		impl TryFrom<$ty> for NumValue {491			type Error = ConvertNumValueError;492			#[inline]493			fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {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}