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

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::{parse_function_call, ArgsLike, Builtin, StaticBuiltin},9	gc::TraceBox,10	native::NativeCallback,11	throw, Context, ObjValue, Result,12};13use gcmodule::{Cc, Trace};14use jrsonnet_interner::IStr;15use jrsonnet_parser::{ExprLocation, LocExpr, ParamsDesc};16use jrsonnet_types::ValType;17use std::{cell::RefCell, fmt::Debug, rc::Rc};1819pub trait LazyValValue: Trace {20	fn get(self: Box<Self>) -> Result<Val>;21}2223#[derive(Trace)]24enum LazyValInternals {25	Computed(Val),26	Errored(LocError),27	Waiting(TraceBox<dyn LazyValValue>),28	Pending,29}3031#[derive(Clone, Trace)]32pub struct LazyVal(Cc<RefCell<LazyValInternals>>);33impl LazyVal {34	pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {35		Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))36	}37	pub fn new_resolved(val: Val) -> Self {38		Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))39	}40	pub fn force(&self) -> Result<()> {41		self.evaluate()?;42		Ok(())43	}44	pub fn evaluate(&self) -> Result<Val> {45		match &*self.0.borrow() {46			LazyValInternals::Computed(v) => return Ok(v.clone()),47			LazyValInternals::Errored(e) => return Err(e.clone()),48			LazyValInternals::Pending => return Err(RecursiveLazyValueEvaluation.into()),49			_ => (),50		};51		let value = if let LazyValInternals::Waiting(value) =52			std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)53		{54			value55		} else {56			unreachable!()57		};58		let new_value = match value.0.get() {59			Ok(v) => v,60			Err(e) => {61				*self.0.borrow_mut() = LazyValInternals::Errored(e.clone());62				return Err(e);63			}64		};65		*self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());66		Ok(new_value)67	}68}6970impl Debug for LazyVal {71	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {72		write!(f, "Lazy")73	}74}75impl PartialEq for LazyVal {76	fn eq(&self, other: &Self) -> bool {77		cc_ptr_eq(&self.0, &other.0)78	}79}8081#[derive(Debug, PartialEq, Trace)]82pub struct FuncDesc {83	pub name: IStr,84	pub ctx: Context,85	pub params: ParamsDesc,86	pub body: LocExpr,87}8889#[derive(Trace)]90pub enum FuncVal {91	/// Plain function implemented in jsonnet92	Normal(FuncDesc),93	/// Standard library function94	StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),9596	Builtin(TraceBox<dyn Builtin>),97	/// Library functions implemented in native98	NativeExt(IStr, Cc<NativeCallback>),99}100101impl Debug for FuncVal {102	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {103		match self {104			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),105			Self::StaticBuiltin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),106			Self::Builtin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),107			Self::NativeExt(arg0, arg1) => {108				f.debug_tuple("NativeExt").field(arg0).field(arg1).finish()109			}110		}111	}112}113114impl PartialEq for FuncVal {115	fn eq(&self, other: &Self) -> bool {116		match (self, other) {117			(Self::Normal(a), Self::Normal(b)) => a == b,118			(Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),119			(Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,120			(..) => false,121		}122	}123}124impl FuncVal {125	pub fn args_len(&self) -> usize {126		match self {127			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),128			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),129			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),130			Self::NativeExt(_, n) => n.params.iter().filter(|p| p.1.is_none()).count(),131		}132	}133	pub fn name(&self) -> IStr {134		match self {135			Self::Normal(normal) => normal.name.clone(),136			Self::StaticBuiltin(builtin) => builtin.name().into(),137			Self::Builtin(builtin) => builtin.name().into(),138			Self::NativeExt(n, _) => format!("native.{}", n).into(),139		}140	}141	pub fn evaluate(142		&self,143		call_ctx: Context,144		loc: Option<&ExprLocation>,145		args: &dyn ArgsLike,146		tailstrict: bool,147	) -> Result<Val> {148		match self {149			Self::Normal(func) => {150				let ctx = parse_function_call(151					call_ctx,152					func.ctx.clone(),153					&func.params,154					args,155					tailstrict,156				)?;157				evaluate(ctx, &func.body)158			}159			Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),160			Self::Builtin(b) => b.call(call_ctx, loc, args),161			Self::NativeExt(_name, handler) => {162				let args =163					parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;164				let mut out_args = Vec::with_capacity(handler.params.len());165				for p in handler.params.0.iter() {166					out_args.push(args.binding(p.0.clone())?.evaluate()?);167				}168				Ok(handler.call(loc.expect("todo").0.clone(), &out_args)?)169			}170		}171	}172	pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {173		self.evaluate(Context::default(), None, args, true)174	}175}176177#[derive(Clone)]178pub enum ManifestFormat {179	YamlStream(Box<ManifestFormat>),180	Yaml(usize),181	Json(usize),182	ToString,183	String,184}185186#[derive(Debug, Clone, Trace)]187#[force_tracking]188pub enum ArrValue {189	Lazy(Cc<Vec<LazyVal>>),190	Eager(Cc<Vec<Val>>),191	Extended(Box<(Self, Self)>),192}193impl ArrValue {194	pub fn new_eager() -> Self {195		Self::Eager(Cc::new(Vec::new()))196	}197198	pub fn len(&self) -> usize {199		match self {200			Self::Lazy(l) => l.len(),201			Self::Eager(e) => e.len(),202			Self::Extended(v) => v.0.len() + v.1.len(),203		}204	}205206	pub fn is_empty(&self) -> bool {207		self.len() == 0208	}209210	pub fn get(&self, index: usize) -> Result<Option<Val>> {211		match self {212			Self::Lazy(vec) => {213				if let Some(v) = vec.get(index) {214					Ok(Some(v.evaluate()?))215				} else {216					Ok(None)217				}218			}219			Self::Eager(vec) => Ok(vec.get(index).cloned()),220			Self::Extended(v) => {221				let a_len = v.0.len();222				if a_len > index {223					v.0.get(index)224				} else {225					v.1.get(index - a_len)226				}227			}228		}229	}230231	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {232		match self {233			Self::Lazy(vec) => vec.get(index).cloned(),234			Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),235			Self::Extended(v) => {236				let a_len = v.0.len();237				if a_len > index {238					v.0.get_lazy(index)239				} else {240					v.1.get_lazy(index - a_len)241				}242			}243		}244	}245246	pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {247		Ok(match self {248			Self::Lazy(vec) => {249				let mut out = Vec::with_capacity(vec.len());250				for item in vec.iter() {251					out.push(item.evaluate()?);252				}253				Cc::new(out)254			}255			Self::Eager(vec) => vec.clone(),256			Self::Extended(_v) => {257				let mut out = Vec::with_capacity(self.len());258				for item in self.iter() {259					out.push(item?);260				}261				Cc::new(out)262			}263		})264	}265266	pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {267		(0..self.len()).map(move |idx| match self {268			Self::Lazy(l) => l[idx].evaluate(),269			Self::Eager(e) => Ok(e[idx].clone()),270			Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),271		})272	}273274	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {275		(0..self.len()).map(move |idx| match self {276			Self::Lazy(l) => l[idx].clone(),277			Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),278			Self::Extended(_) => self.get_lazy(idx).unwrap(),279		})280	}281282	pub fn reversed(self) -> Self {283		match self {284			Self::Lazy(vec) => {285				let mut out = (&vec as &Vec<_>).clone();286				out.reverse();287				Self::Lazy(Cc::new(out))288			}289			Self::Eager(vec) => {290				let mut out = (&vec as &Vec<_>).clone();291				out.reverse();292				Self::Eager(Cc::new(out))293			}294			Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),295		}296	}297298	pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {299		let mut out = Vec::with_capacity(self.len());300301		for value in self.iter() {302			out.push(mapper(value?)?);303		}304305		Ok(Self::Eager(Cc::new(out)))306	}307308	pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {309		let mut out = Vec::with_capacity(self.len());310311		for value in self.iter() {312			let value = value?;313			if filter(&value)? {314				out.push(value);315			}316		}317318		Ok(Self::Eager(Cc::new(out)))319	}320321	pub fn ptr_eq(a: &Self, b: &Self) -> bool {322		match (a, b) {323			(Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),324			(Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),325			_ => false,326		}327	}328}329330impl From<Vec<LazyVal>> for ArrValue {331	fn from(v: Vec<LazyVal>) -> Self {332		Self::Lazy(Cc::new(v))333	}334}335336impl From<Vec<Val>> for ArrValue {337	fn from(v: Vec<Val>) -> Self {338		Self::Eager(Cc::new(v))339	}340}341342pub enum IndexableVal {343	Str(IStr),344	Arr(ArrValue),345}346347#[derive(Debug, Clone, Trace)]348pub enum Val {349	Bool(bool),350	Null,351	Str(IStr),352	Num(f64),353	Arr(ArrValue),354	Obj(ObjValue),355	Func(Cc<FuncVal>),356}357358impl Val {359	/// Creates `Val::Num` after checking for numeric overflow.360	/// As numbers are `f64`, we can just check for their finity.361	pub fn new_checked_num(num: f64) -> Result<Self> {362		if num.is_finite() {363			Ok(Self::Num(num))364		} else {365			throw!(RuntimeError("overflow".into()))366		}367	}368369	pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {370		Ok(match self {371			Val::Null => None,372			Val::Num(num) => Some(num),373			_ => throw!(TypeMismatch(374				context,375				vec![ValType::Null, ValType::Num],376				self.value_type()377			)),378		})379	}380	pub const fn value_type(&self) -> ValType {381		match self {382			Self::Str(..) => ValType::Str,383			Self::Num(..) => ValType::Num,384			Self::Arr(..) => ValType::Arr,385			Self::Obj(..) => ValType::Obj,386			Self::Bool(_) => ValType::Bool,387			Self::Null => ValType::Null,388			Self::Func(..) => ValType::Func,389		}390	}391392	pub fn to_string(&self) -> Result<IStr> {393		Ok(match self {394			Self::Bool(true) => "true".into(),395			Self::Bool(false) => "false".into(),396			Self::Null => "null".into(),397			Self::Str(s) => s.clone(),398			v => manifest_json_ex(399				v,400				&ManifestJsonOptions {401					padding: "",402					mtype: ManifestType::ToString,403					newline: "\n",404					key_val_sep: ": ",405				},406			)?407			.into(),408		})409	}410411	/// Expects value to be object, outputs (key, manifested value) pairs412	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {413		let obj = match self {414			Self::Obj(obj) => obj,415			_ => throw!(MultiManifestOutputIsNotAObject),416		};417		let keys = obj.fields();418		let mut out = Vec::with_capacity(keys.len());419		for key in keys {420			let value = obj421				.get(key.clone())?422				.expect("item in object")423				.manifest(ty)?;424			out.push((key, value));425		}426		Ok(out)427	}428429	/// Expects value to be array, outputs manifested values430	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {431		let arr = match self {432			Self::Arr(a) => a,433			_ => throw!(StreamManifestOutputIsNotAArray),434		};435		let mut out = Vec::with_capacity(arr.len());436		for i in arr.iter() {437			out.push(i?.manifest(ty)?);438		}439		Ok(out)440	}441442	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {443		Ok(match ty {444			ManifestFormat::YamlStream(format) => {445				let arr = match self {446					Self::Arr(a) => a,447					_ => throw!(StreamManifestOutputIsNotAArray),448				};449				let mut out = String::new();450451				match format as &ManifestFormat {452					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),453					ManifestFormat::String => throw!(StreamManifestCannotNestString),454					_ => {}455				};456457				if !arr.is_empty() {458					for v in arr.iter() {459						out.push_str("---\n");460						out.push_str(&v?.manifest(format)?);461						out.push('\n');462					}463					out.push_str("...");464				}465466				out.into()467			}468			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,469			ManifestFormat::Json(padding) => self.to_json(*padding)?,470			ManifestFormat::ToString => self.to_string()?,471			ManifestFormat::String => match self {472				Self::Str(s) => s.clone(),473				_ => throw!(StringManifestOutputIsNotAString),474			},475		})476	}477478	/// For manifestification479	pub fn to_json(&self, padding: usize) -> Result<IStr> {480		manifest_json_ex(481			self,482			&ManifestJsonOptions {483				padding: &" ".repeat(padding),484				mtype: if padding == 0 {485					ManifestType::Minify486				} else {487					ManifestType::Manifest488				},489				newline: "\n",490				key_val_sep: ": ",491			},492		)493		.map(|s| s.into())494	}495496	/// Calls `std.manifestJson`497	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {498		manifest_json_ex(499			self,500			&ManifestJsonOptions {501				padding: &" ".repeat(padding),502				mtype: ManifestType::Std,503				newline: "\n",504				key_val_sep: ": ",505			},506		)507		.map(|s| s.into())508	}509510	pub fn to_yaml(&self, padding: usize) -> Result<IStr> {511		let padding = &" ".repeat(padding);512		manifest_yaml_ex(513			self,514			&ManifestYamlOptions {515				padding,516				arr_element_padding: padding,517				quote_keys: false,518			},519		)520		.map(|s| s.into())521	}522	pub fn into_indexable(self) -> Result<IndexableVal> {523		Ok(match self {524			Val::Str(s) => IndexableVal::Str(s),525			Val::Arr(arr) => IndexableVal::Arr(arr),526			_ => throw!(ValueIsNotIndexable(self.value_type())),527		})528	}529}530531const fn is_function_like(val: &Val) -> bool {532	matches!(val, Val::Func(_))533}534535/// Native implementation of `std.primitiveEquals`536pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {537	Ok(match (val_a, val_b) {538		(Val::Bool(a), Val::Bool(b)) => a == b,539		(Val::Null, Val::Null) => true,540		(Val::Str(a), Val::Str(b)) => a == b,541		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,542		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(543			"primitiveEquals operates on primitive types, got array".into(),544		)),545		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(546			"primitiveEquals operates on primitive types, got object".into(),547		)),548		(a, b) if is_function_like(a) && is_function_like(b) => {549			throw!(RuntimeError("cannot test equality of functions".into()))550		}551		(_, _) => false,552	})553}554555/// Native implementation of `std.equals`556pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {557	if val_a.value_type() != val_b.value_type() {558		return Ok(false);559	}560	match (val_a, val_b) {561		(Val::Arr(a), Val::Arr(b)) => {562			if ArrValue::ptr_eq(a, b) {563				return Ok(true);564			}565			if a.len() != b.len() {566				return Ok(false);567			}568			for (a, b) in a.iter().zip(b.iter()) {569				if !equals(&a?, &b?)? {570					return Ok(false);571				}572			}573			Ok(true)574		}575		(Val::Obj(a), Val::Obj(b)) => {576			if ObjValue::ptr_eq(a, b) {577				return Ok(true);578			}579			let fields = a.fields();580			if fields != b.fields() {581				return Ok(false);582			}583			for field in fields {584				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {585					return Ok(false);586				}587			}588			Ok(true)589		}590		(a, b) => Ok(primitive_equals(a, b)?),591	}592}