git.delta.rocks / jrsonnet / refs/commits / 4c008687f967

1use crate::{2	builtin::manifest::{3		manifest_json_ex, manifest_yaml_ex, ManifestJsonOptions, ManifestType, ManifestYamlOptions,4	},5	cc_ptr_eq,6	error::{Error::*, LocError},7	evaluate,8	function::{9		parse_default_function_call, parse_function_call, ArgsLike, Builtin, CallLocation,10		StaticBuiltin,11	},12	gc::TraceBox,13	throw, Context, ObjValue, Result,14};15use gcmodule::{Cc, Trace};16use jrsonnet_interner::IStr;17use jrsonnet_parser::{LocExpr, ParamsDesc};18use jrsonnet_types::ValType;19use std::{cell::RefCell, fmt::Debug, rc::Rc};2021pub trait LazyValValue: Trace {22	fn get(self: Box<Self>) -> Result<Val>;23}2425#[derive(Trace)]26enum LazyValInternals {27	Computed(Val),28	Errored(LocError),29	Waiting(TraceBox<dyn LazyValValue>),30	Pending,31}3233#[derive(Clone, Trace)]34pub struct LazyVal(Cc<RefCell<LazyValInternals>>);35impl LazyVal {36	pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {37		Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))38	}39	pub fn new_resolved(val: Val) -> Self {40		Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))41	}42	pub fn force(&self) -> Result<()> {43		self.evaluate()?;44		Ok(())45	}46	pub fn evaluate(&self) -> Result<Val> {47		match &*self.0.borrow() {48			LazyValInternals::Computed(v) => return Ok(v.clone()),49			LazyValInternals::Errored(e) => return Err(e.clone()),50			LazyValInternals::Pending => return Err(InfiniteRecursionDetected.into()),51			_ => (),52		};53		let value = if let LazyValInternals::Waiting(value) =54			std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)55		{56			value57		} else {58			unreachable!()59		};60		let new_value = match value.0.get() {61			Ok(v) => v,62			Err(e) => {63				*self.0.borrow_mut() = LazyValInternals::Errored(e.clone());64				return Err(e);65			}66		};67		*self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());68		Ok(new_value)69	}70}7172impl Debug for LazyVal {73	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {74		write!(f, "Lazy")75	}76}77impl PartialEq for LazyVal {78	fn eq(&self, other: &Self) -> bool {79		cc_ptr_eq(&self.0, &other.0)80	}81}8283#[derive(Debug, PartialEq, Trace)]84pub struct FuncDesc {85	pub name: IStr,86	pub ctx: Context,87	pub params: ParamsDesc,88	pub body: LocExpr,89}90impl FuncDesc {91	/// Create body context, but fill arguments without defaults with lazy error92	pub fn default_body_context(&self) -> Context {93		parse_default_function_call(self.ctx.clone(), &self.params)94	}9596	/// Create context, with which body code will run97	pub fn call_body_context(98		&self,99		call_ctx: Context,100		args: &dyn ArgsLike,101		tailstrict: bool,102	) -> Result<Context> {103		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)104	}105}106107#[derive(Trace, Clone)]108pub enum FuncVal {109	/// Plain function implemented in jsonnet110	Normal(Cc<FuncDesc>),111	/// Standard library function112	StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),113	/// User-provided function114	Builtin(Cc<TraceBox<dyn Builtin>>),115}116117impl Debug for FuncVal {118	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {119		match self {120			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),121			Self::StaticBuiltin(arg0) => {122				f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()123			}124			Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),125		}126	}127}128129impl FuncVal {130	pub fn args_len(&self) -> usize {131		match self {132			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),133			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),134			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),135		}136	}137	pub fn name(&self) -> IStr {138		match self {139			Self::Normal(normal) => normal.name.clone(),140			Self::StaticBuiltin(builtin) => builtin.name().into(),141			Self::Builtin(builtin) => builtin.name().into(),142		}143	}144	pub fn evaluate(145		&self,146		call_ctx: Context,147		loc: CallLocation,148		args: &dyn ArgsLike,149		tailstrict: bool,150	) -> Result<Val> {151		match self {152			Self::Normal(func) => {153				let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;154				evaluate(body_ctx, &func.body)155			}156			Self::StaticBuiltin(b) => b.call(call_ctx, loc, args),157			Self::Builtin(b) => b.call(call_ctx, loc, args),158		}159	}160	pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {161		self.evaluate(Context::default(), CallLocation::native(), args, true)162	}163}164165#[derive(Clone)]166pub enum ManifestFormat {167	YamlStream(Box<ManifestFormat>),168	Yaml(usize),169	Json(usize),170	ToString,171	String,172}173174#[derive(Debug, Clone, Trace)]175pub struct Slice {176	pub(crate) inner: ArrValue,177	pub(crate) from: u32,178	pub(crate) to: u32,179	pub(crate) step: u32,180}181impl Slice {182	fn from(&self) -> usize {183		self.from as usize184	}185	fn to(&self) -> usize {186		self.to as usize187	}188	fn step(&self) -> usize {189		self.step as usize190	}191	fn len(&self) -> usize {192		// TODO: use div_ceil193		let diff = self.to() - self.from();194		let rem = diff % self.step();195		let div = diff / self.step();196197		if rem != 0 {198			div + 1199		} else {200			div201		}202	}203}204205#[derive(Debug, Clone, Trace)]206#[force_tracking]207pub enum ArrValue {208	Bytes(#[skip_trace] Rc<[u8]>),209	Lazy(Cc<Vec<LazyVal>>),210	Eager(Cc<Vec<Val>>),211	Extended(Box<(Self, Self)>),212	Range(i32, i32),213	Slice(Box<Slice>),214	Reversed(Box<Self>),215}216impl ArrValue {217	pub fn new_eager() -> Self {218		Self::Eager(Cc::new(Vec::new()))219	}220	pub fn new_range(a: i32, b: i32) -> Self {221		assert!(a <= b);222		Self::Range(a, b)223	}224225	pub fn slice(self, from: Option<usize>, to: Option<usize>, step: Option<usize>) -> Self {226		let len = self.len();227		let from = from.unwrap_or(0);228		let to = to.unwrap_or(len).min(len);229		let step = step.unwrap_or(1);230		assert!(from < to);231		assert!(step > 0);232233		Self::Slice(Box::new(Slice {234			inner: self,235			from: from as u32,236			to: to as u32,237			step: step as u32,238		}))239	}240241	pub fn len(&self) -> usize {242		match self {243			Self::Bytes(i) => i.len(),244			Self::Lazy(l) => l.len(),245			Self::Eager(e) => e.len(),246			Self::Extended(v) => v.0.len() + v.1.len(),247			Self::Range(a, b) => a.abs_diff(*b) as usize,248			Self::Reversed(i) => i.len(),249			Self::Slice(s) => s.len(),250		}251	}252253	pub fn is_empty(&self) -> bool {254		self.len() == 0255	}256257	pub fn get(&self, index: usize) -> Result<Option<Val>> {258		match self {259			Self::Bytes(i) => i260				.get(index)261				.map_or(Ok(None), |v| Ok(Some(Val::Num(*v as f64)))),262			Self::Lazy(vec) => {263				if let Some(v) = vec.get(index) {264					Ok(Some(v.evaluate()?))265				} else {266					Ok(None)267				}268			}269			Self::Eager(vec) => Ok(vec.get(index).cloned()),270			Self::Extended(v) => {271				let a_len = v.0.len();272				if a_len > index {273					v.0.get(index)274				} else {275					v.1.get(index - a_len)276				}277			}278			Self::Range(a, _) => {279				if index >= self.len() {280					return Ok(None);281				}282				Ok(Some(Val::Num(((*a as isize) + index as isize) as f64)))283			}284			Self::Reversed(v) => {285				let len = v.len();286				if index >= len {287					return Ok(None);288				}289				v.get(len - index - 1)290			}291			Self::Slice(s) => {292				let index = s.from() + index * s.step();293				if index >= s.to() {294					return Ok(None);295				}296				s.inner.get(index as usize)297			}298		}299	}300301	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {302		match self {303			Self::Bytes(i) => i304				.get(index)305				.map(|b| LazyVal::new_resolved(Val::Num(*b as f64))),306			Self::Lazy(vec) => vec.get(index).cloned(),307			Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),308			Self::Extended(v) => {309				let a_len = v.0.len();310				if a_len > index {311					v.0.get_lazy(index)312				} else {313					v.1.get_lazy(index - a_len)314				}315			}316			Self::Range(a, _) => {317				if index >= self.len() {318					return None;319				}320				Some(LazyVal::new_resolved(Val::Num(321					((*a as isize) + index as isize) as f64,322				)))323			}324			Self::Reversed(v) => {325				let len = v.len();326				if index >= len {327					return None;328				}329				v.get_lazy(len - index - 1)330			}331			Self::Slice(s) => {332				let index = s.from() + index * s.step();333				if index >= s.to() {334					return None;335				}336				s.inner.get_lazy(index as usize)337			}338		}339	}340341	pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {342		Ok(match self {343			Self::Bytes(i) => {344				let mut out = Vec::with_capacity(i.len());345				for v in i.iter() {346					out.push(Val::Num(*v as f64));347				}348				Cc::new(out)349			}350			Self::Lazy(vec) => {351				let mut out = Vec::with_capacity(vec.len());352				for item in vec.iter() {353					out.push(item.evaluate()?);354				}355				Cc::new(out)356			}357			Self::Eager(vec) => vec.clone(),358			Self::Extended(_v) => {359				let mut out = Vec::with_capacity(self.len());360				for item in self.iter() {361					out.push(item?);362				}363				Cc::new(out)364			}365			Self::Range(a, b) => {366				let mut out = Vec::with_capacity(self.len());367				for i in *a..*b {368					out.push(Val::Num(i as f64));369				}370				Cc::new(out)371			}372			Self::Reversed(r) => {373				let mut r = r.evaluated()?;374				Cc::update_with(&mut r, |v| v.reverse());375				r376			}377			Self::Slice(v) => {378				let mut out = Vec::with_capacity(v.inner.len());379				for v in v380					.inner381					.iter_lazy()382					.skip(v.from())383					.take(v.to() - v.from())384					.step_by(v.step())385				{386					out.push(v.evaluate()?)387				}388				Cc::new(out)389			}390		})391	}392393	pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {394		(0..self.len()).map(move |idx| match self {395			Self::Bytes(b) => Ok(Val::Num(b[idx] as f64)),396			Self::Lazy(l) => l[idx].evaluate(),397			Self::Eager(e) => Ok(e[idx].clone()),398			Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),399			Self::Range(..) => self.get(idx).map(|e| e.unwrap()),400			Self::Reversed(..) => self.get(idx).map(|e| e.unwrap()),401			Self::Slice(..) => self.get(idx).map(|e| e.unwrap()),402		})403	}404405	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {406		(0..self.len()).map(move |idx| match self {407			Self::Bytes(b) => LazyVal::new_resolved(Val::Num(b[idx] as f64)),408			Self::Lazy(l) => l[idx].clone(),409			Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),410			Self::Extended(_) => self.get_lazy(idx).unwrap(),411			Self::Range(..) => self.get_lazy(idx).unwrap(),412			Self::Reversed(..) => self.get_lazy(idx).unwrap(),413			Self::Slice(..) => self.get_lazy(idx).unwrap(),414		})415	}416417	pub fn reversed(self) -> Self {418		Self::Reversed(Box::new(self))419	}420421	pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {422		let mut out = Vec::with_capacity(self.len());423424		for value in self.iter() {425			out.push(mapper(value?)?);426		}427428		Ok(Self::Eager(Cc::new(out)))429	}430431	pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {432		let mut out = Vec::with_capacity(self.len());433434		for value in self.iter() {435			let value = value?;436			if filter(&value)? {437				out.push(value);438			}439		}440441		Ok(Self::Eager(Cc::new(out)))442	}443444	pub fn ptr_eq(a: &Self, b: &Self) -> bool {445		match (a, b) {446			(Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),447			(Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),448			_ => false,449		}450	}451}452453impl From<Vec<LazyVal>> for ArrValue {454	fn from(v: Vec<LazyVal>) -> Self {455		Self::Lazy(Cc::new(v))456	}457}458459impl From<Vec<Val>> for ArrValue {460	fn from(v: Vec<Val>) -> Self {461		Self::Eager(Cc::new(v))462	}463}464465pub enum IndexableVal {466	Str(IStr),467	Arr(ArrValue),468}469470#[derive(Debug, Clone, Trace)]471pub enum Val {472	Bool(bool),473	Null,474	Str(IStr),475	Num(f64),476	Arr(ArrValue),477	Obj(ObjValue),478	Func(FuncVal),479}480481impl Val {482	pub const fn as_bool(&self) -> Option<bool> {483		match self {484			Val::Bool(v) => Some(*v),485			_ => None,486		}487	}488	pub const fn as_null(&self) -> Option<()> {489		match self {490			Val::Null => Some(()),491			_ => None,492		}493	}494	pub fn as_str(&self) -> Option<IStr> {495		match self {496			Val::Str(s) => Some(s.clone()),497			_ => None,498		}499	}500	pub const fn as_num(&self) -> Option<f64> {501		match self {502			Val::Num(n) => Some(*n),503			_ => None,504		}505	}506	pub fn as_arr(&self) -> Option<ArrValue> {507		match self {508			Val::Arr(a) => Some(a.clone()),509			_ => None,510		}511	}512	pub fn as_obj(&self) -> Option<ObjValue> {513		match self {514			Val::Obj(o) => Some(o.clone()),515			_ => None,516		}517	}518	pub fn as_func(&self) -> Option<FuncVal> {519		match self {520			Val::Func(f) => Some(f.clone()),521			_ => None,522		}523	}524525	/// Creates `Val::Num` after checking for numeric overflow.526	/// As numbers are `f64`, we can just check for their finity.527	pub fn new_checked_num(num: f64) -> Result<Self> {528		if num.is_finite() {529			Ok(Self::Num(num))530		} else {531			throw!(RuntimeError("overflow".into()))532		}533	}534535	pub const fn value_type(&self) -> ValType {536		match self {537			Self::Str(..) => ValType::Str,538			Self::Num(..) => ValType::Num,539			Self::Arr(..) => ValType::Arr,540			Self::Obj(..) => ValType::Obj,541			Self::Bool(_) => ValType::Bool,542			Self::Null => ValType::Null,543			Self::Func(..) => ValType::Func,544		}545	}546547	pub fn to_string(&self) -> Result<IStr> {548		Ok(match self {549			Self::Bool(true) => "true".into(),550			Self::Bool(false) => "false".into(),551			Self::Null => "null".into(),552			Self::Str(s) => s.clone(),553			v => manifest_json_ex(554				v,555				&ManifestJsonOptions {556					padding: "",557					mtype: ManifestType::ToString,558					newline: "\n",559					key_val_sep: ": ",560				},561			)?562			.into(),563		})564	}565566	/// Expects value to be object, outputs (key, manifested value) pairs567	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {568		let obj = match self {569			Self::Obj(obj) => obj,570			_ => throw!(MultiManifestOutputIsNotAObject),571		};572		let keys = obj.fields();573		let mut out = Vec::with_capacity(keys.len());574		for key in keys {575			let value = obj576				.get(key.clone())?577				.expect("item in object")578				.manifest(ty)?;579			out.push((key, value));580		}581		Ok(out)582	}583584	/// Expects value to be array, outputs manifested values585	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {586		let arr = match self {587			Self::Arr(a) => a,588			_ => throw!(StreamManifestOutputIsNotAArray),589		};590		let mut out = Vec::with_capacity(arr.len());591		for i in arr.iter() {592			out.push(i?.manifest(ty)?);593		}594		Ok(out)595	}596597	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {598		Ok(match ty {599			ManifestFormat::YamlStream(format) => {600				let arr = match self {601					Self::Arr(a) => a,602					_ => throw!(StreamManifestOutputIsNotAArray),603				};604				let mut out = String::new();605606				match format as &ManifestFormat {607					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),608					ManifestFormat::String => throw!(StreamManifestCannotNestString),609					_ => {}610				};611612				if !arr.is_empty() {613					for v in arr.iter() {614						out.push_str("---\n");615						out.push_str(&v?.manifest(format)?);616						out.push('\n');617					}618					out.push_str("...");619				}620621				out.into()622			}623			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,624			ManifestFormat::Json(padding) => self.to_json(*padding)?,625			ManifestFormat::ToString => self.to_string()?,626			ManifestFormat::String => match self {627				Self::Str(s) => s.clone(),628				_ => throw!(StringManifestOutputIsNotAString),629			},630		})631	}632633	/// For manifestification634	pub fn to_json(&self, padding: usize) -> Result<IStr> {635		manifest_json_ex(636			self,637			&ManifestJsonOptions {638				padding: &" ".repeat(padding),639				mtype: if padding == 0 {640					ManifestType::Minify641				} else {642					ManifestType::Manifest643				},644				newline: "\n",645				key_val_sep: ": ",646			},647		)648		.map(|s| s.into())649	}650651	/// Calls `std.manifestJson`652	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {653		manifest_json_ex(654			self,655			&ManifestJsonOptions {656				padding: &" ".repeat(padding),657				mtype: ManifestType::Std,658				newline: "\n",659				key_val_sep: ": ",660			},661		)662		.map(|s| s.into())663	}664665	pub fn to_yaml(&self, padding: usize) -> Result<IStr> {666		let padding = &" ".repeat(padding);667		manifest_yaml_ex(668			self,669			&ManifestYamlOptions {670				padding,671				arr_element_padding: padding,672				quote_keys: false,673			},674		)675		.map(|s| s.into())676	}677	pub fn into_indexable(self) -> Result<IndexableVal> {678		Ok(match self {679			Val::Str(s) => IndexableVal::Str(s),680			Val::Arr(arr) => IndexableVal::Arr(arr),681			_ => throw!(ValueIsNotIndexable(self.value_type())),682		})683	}684}685686const fn is_function_like(val: &Val) -> bool {687	matches!(val, Val::Func(_))688}689690/// Native implementation of `std.primitiveEquals`691pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {692	Ok(match (val_a, val_b) {693		(Val::Bool(a), Val::Bool(b)) => a == b,694		(Val::Null, Val::Null) => true,695		(Val::Str(a), Val::Str(b)) => a == b,696		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,697		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(698			"primitiveEquals operates on primitive types, got array".into(),699		)),700		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(701			"primitiveEquals operates on primitive types, got object".into(),702		)),703		(a, b) if is_function_like(a) && is_function_like(b) => {704			throw!(RuntimeError("cannot test equality of functions".into()))705		}706		(_, _) => false,707	})708}709710/// Native implementation of `std.equals`711pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {712	if val_a.value_type() != val_b.value_type() {713		return Ok(false);714	}715	match (val_a, val_b) {716		(Val::Arr(a), Val::Arr(b)) => {717			if ArrValue::ptr_eq(a, b) {718				return Ok(true);719			}720			if a.len() != b.len() {721				return Ok(false);722			}723			for (a, b) in a.iter().zip(b.iter()) {724				if !equals(&a?, &b?)? {725					return Ok(false);726				}727			}728			Ok(true)729		}730		(Val::Obj(a), Val::Obj(b)) => {731			if ObjValue::ptr_eq(a, b) {732				return Ok(true);733			}734			let fields = a.fields();735			if fields != b.fields() {736				return Ok(false);737			}738			for field in fields {739				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {740					return Ok(false);741				}742			}743			Ok(true)744		}745		(a, b) => Ok(primitive_equals(a, b)?),746	}747}