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

1use crate::{2	builtin::{3		call_builtin,4		manifest::{manifest_json_ex, ManifestJsonOptions, ManifestType},5	},6	error::{Error::*, LocError},7	evaluate,8	function::{parse_function_call, parse_function_call_map, place_args},9	native::NativeCallback,10	throw, with_state, Context, ObjValue, Result,11};12use jrsonnet_gc::{Gc, GcCell, Trace};13use jrsonnet_interner::IStr;14use jrsonnet_parser::{el, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};15use jrsonnet_types::ValType;16use std::{collections::HashMap, fmt::Debug, rc::Rc};1718pub trait LazyValValue: Trace {19	fn get(self: Box<Self>) -> Result<Val>;20}2122#[derive(Trace)]23#[trivially_drop]24enum LazyValInternals {25	Computed(Val),26	Errored(LocError),27	Waiting(Box<dyn LazyValValue>),28	Pending,29}3031#[derive(Clone, Trace)]32#[trivially_drop]33pub struct LazyVal(Gc<GcCell<LazyValInternals>>);34impl LazyVal {35	pub fn new(f: Box<dyn LazyValValue>) -> Self {36		Self(Gc::new(GcCell::new(LazyValInternals::Waiting(f))))37	}38	pub fn new_resolved(val: Val) -> Self {39		Self(Gc::new(GcCell::new(LazyValInternals::Computed(val))))40	}41	pub fn evaluate(&self) -> Result<Val> {42		match &*self.0.borrow() {43			LazyValInternals::Computed(v) => return Ok(v.clone()),44			LazyValInternals::Errored(e) => return Err(e.clone()),45			LazyValInternals::Pending => return Err(RecursiveLazyValueEvaluation.into()),46			_ => (),47		};48		let value = if let LazyValInternals::Waiting(value) =49			std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)50		{51			value52		} else {53			unreachable!()54		};55		let new_value = match value.get() {56			Ok(v) => v,57			Err(e) => {58				*self.0.borrow_mut() = LazyValInternals::Errored(e.clone());59				return Err(e);60			}61		};62		*self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());63		Ok(new_value)64	}65}6667impl Debug for LazyVal {68	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {69		write!(f, "Lazy")70	}71}72impl PartialEq for LazyVal {73	fn eq(&self, other: &Self) -> bool {74		Gc::ptr_eq(&self.0, &other.0)75	}76}7778#[derive(Debug, PartialEq, Trace)]79#[trivially_drop]80pub struct FuncDesc {81	pub name: IStr,82	pub ctx: Context,83	pub params: ParamsDesc,84	pub body: LocExpr,85}8687#[derive(Debug, Trace)]88#[trivially_drop]89pub enum FuncVal {90	/// Plain function implemented in jsonnet91	Normal(FuncDesc),92	/// Standard library function93	Intrinsic(IStr),94	/// Library functions implemented in native95	NativeExt(IStr, Gc<NativeCallback>),96}9798impl PartialEq for FuncVal {99	fn eq(&self, other: &Self) -> bool {100		match (self, other) {101			(Self::Normal(a), Self::Normal(b)) => a == b,102			(Self::Intrinsic(an), Self::Intrinsic(bn)) => an == bn,103			(Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,104			(..) => false,105		}106	}107}108impl FuncVal {109	pub fn is_ident(&self) -> bool {110		matches!(&self, Self::Intrinsic(n) if n as &str == "id")111	}112	pub fn name(&self) -> IStr {113		match self {114			Self::Normal(normal) => normal.name.clone(),115			Self::Intrinsic(name) => format!("std.{}", name).into(),116			Self::NativeExt(n, _) => format!("native.{}", n).into(),117		}118	}119	pub fn evaluate(120		&self,121		call_ctx: Context,122		loc: Option<&ExprLocation>,123		args: &ArgsDesc,124		tailstrict: bool,125	) -> Result<Val> {126		match self {127			Self::Normal(func) => {128				let ctx = parse_function_call(129					call_ctx,130					func.ctx.clone(),131					&func.params,132					args,133					tailstrict,134				)?;135				evaluate(ctx, &func.body)136			}137			Self::Intrinsic(name) => call_builtin(call_ctx, loc, name, args),138			Self::NativeExt(_name, handler) => {139				let args =140					parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;141				let mut out_args = Vec::with_capacity(handler.params.len());142				for p in handler.params.0.iter() {143					out_args.push(args.binding(p.0.clone())?.evaluate()?);144				}145				Ok(handler.call(loc.map(|l| l.0.clone()), &out_args)?)146			}147		}148	}149150	pub fn evaluate_map(151		&self,152		call_ctx: Context,153		args: &HashMap<IStr, Val>,154		tailstrict: bool,155	) -> Result<Val> {156		match self {157			Self::Normal(func) => {158				let ctx = parse_function_call_map(159					call_ctx,160					Some(func.ctx.clone()),161					&func.params,162					args,163					tailstrict,164				)?;165				evaluate(ctx, &func.body)166			}167			Self::Intrinsic(_) => todo!(),168			Self::NativeExt(_, _) => todo!(),169		}170	}171172	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {173		match self {174			Self::Normal(func) => {175				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;176				evaluate(ctx, &func.body)177			}178			Self::Intrinsic(_) => todo!(),179			Self::NativeExt(_, _) => todo!(),180		}181	}182}183184#[derive(Clone)]185pub enum ManifestFormat {186	YamlStream(Box<ManifestFormat>),187	Yaml(usize),188	Json(usize),189	ToString,190	String,191}192193#[derive(Debug, Clone, Trace)]194#[trivially_drop]195pub enum ArrValue {196	Lazy(Gc<Vec<LazyVal>>),197	Eager(Gc<Vec<Val>>),198	Extended(Box<(Self, Self)>),199}200impl ArrValue {201	pub fn new_eager() -> Self {202		Self::Eager(Gc::new(Vec::new()))203	}204205	pub fn len(&self) -> usize {206		match self {207			Self::Lazy(l) => l.len(),208			Self::Eager(e) => e.len(),209			Self::Extended(v) => v.0.len() + v.1.len(),210		}211	}212213	pub fn is_empty(&self) -> bool {214		self.len() == 0215	}216217	pub fn get(&self, index: usize) -> Result<Option<Val>> {218		match self {219			Self::Lazy(vec) => {220				if let Some(v) = vec.get(index) {221					Ok(Some(v.evaluate()?))222				} else {223					Ok(None)224				}225			}226			Self::Eager(vec) => Ok(vec.get(index).cloned()),227			Self::Extended(v) => {228				let a_len = v.0.len();229				if a_len > index {230					v.0.get(index)231				} else {232					v.1.get(index - a_len)233				}234			}235		}236	}237238	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {239		match self {240			Self::Lazy(vec) => vec.get(index).cloned(),241			Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),242			Self::Extended(v) => {243				let a_len = v.0.len();244				if a_len > index {245					v.0.get_lazy(index)246				} else {247					v.1.get_lazy(index - a_len)248				}249			}250		}251	}252253	pub fn evaluated(&self) -> Result<Gc<Vec<Val>>> {254		Ok(match self {255			Self::Lazy(vec) => {256				let mut out = Vec::with_capacity(vec.len());257				for item in vec.iter() {258					out.push(item.evaluate()?);259				}260				Gc::new(out)261			}262			Self::Eager(vec) => vec.clone(),263			Self::Extended(_v) => {264				let mut out = Vec::with_capacity(self.len());265				for item in self.iter() {266					out.push(item?);267				}268				Gc::new(out)269			}270		})271	}272273	pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {274		(0..self.len()).map(move |idx| match self {275			Self::Lazy(l) => l[idx].evaluate(),276			Self::Eager(e) => Ok(e[idx].clone()),277			Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),278		})279	}280281	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {282		(0..self.len()).map(move |idx| match self {283			Self::Lazy(l) => l[idx].clone(),284			Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),285			Self::Extended(_) => self.get_lazy(idx).unwrap(),286		})287	}288289	pub fn reversed(self) -> Self {290		match self {291			Self::Lazy(vec) => {292				let mut out = (&vec as &Vec<_>).clone();293				out.reverse();294				Self::Lazy(Gc::new(out))295			}296			Self::Eager(vec) => {297				let mut out = (&vec as &Vec<_>).clone();298				out.reverse();299				Self::Eager(Gc::new(out))300			}301			Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),302		}303	}304305	pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {306		let mut out = Vec::with_capacity(self.len());307308		for value in self.iter() {309			out.push(mapper(value?)?);310		}311312		Ok(Self::Eager(Gc::new(out)))313	}314315	pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {316		let mut out = Vec::with_capacity(self.len());317318		for value in self.iter() {319			let value = value?;320			if filter(&value)? {321				out.push(value);322			}323		}324325		Ok(Self::Eager(Gc::new(out)))326	}327328	pub fn ptr_eq(a: &Self, b: &Self) -> bool {329		match (a, b) {330			(Self::Lazy(a), Self::Lazy(b)) => Gc::ptr_eq(a, b),331			(Self::Eager(a), Self::Eager(b)) => Gc::ptr_eq(a, b),332			_ => false,333		}334	}335}336337impl From<Vec<LazyVal>> for ArrValue {338	fn from(v: Vec<LazyVal>) -> Self {339		Self::Lazy(Gc::new(v))340	}341}342343impl From<Vec<Val>> for ArrValue {344	fn from(v: Vec<Val>) -> Self {345		Self::Eager(Gc::new(v))346	}347}348349pub enum IndexableVal {350	Str(IStr),351	Arr(ArrValue),352}353354#[derive(Debug, Clone, Trace)]355#[trivially_drop]356pub enum Val {357	Bool(bool),358	Null,359	Str(IStr),360	Num(f64),361	Arr(ArrValue),362	Obj(ObjValue),363	Func(Gc<FuncVal>),364}365366macro_rules! matches_unwrap {367	($e: expr, $p: pat, $r: expr) => {368		match $e {369			$p => $r,370			_ => panic!("no match"),371		}372	};373}374impl Val {375	/// Creates `Val::Num` after checking for numeric overflow.376	/// As numbers are `f64`, we can just check for their finity.377	pub fn new_checked_num(num: f64) -> Result<Self> {378		if num.is_finite() {379			Ok(Self::Num(num))380		} else {381			throw!(RuntimeError("overflow".into()))382		}383	}384385	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {386		let this_type = self.value_type();387		if this_type != val_type {388			throw!(TypeMismatch(context, vec![val_type], this_type))389		} else {390			Ok(())391		}392	}393	pub fn unwrap_num(self) -> Result<f64> {394		Ok(matches_unwrap!(self, Self::Num(v), v))395	}396	pub fn unwrap_func(self) -> Result<Gc<FuncVal>> {397		Ok(matches_unwrap!(self, Self::Func(v), v))398	}399	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {400		self.assert_type(context, ValType::Bool)?;401		Ok(matches_unwrap!(self, Self::Bool(v), v))402	}403	pub fn try_cast_str(self, context: &'static str) -> Result<IStr> {404		self.assert_type(context, ValType::Str)?;405		Ok(matches_unwrap!(self, Self::Str(v), v))406	}407	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {408		self.assert_type(context, ValType::Num)?;409		self.unwrap_num()410	}411	pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {412		Ok(match self {413			Val::Null => None,414			Val::Num(num) => Some(num),415			_ => throw!(TypeMismatch(416				context,417				vec![ValType::Null, ValType::Num],418				self.value_type()419			)),420		})421	}422	pub const fn value_type(&self) -> ValType {423		match self {424			Self::Str(..) => ValType::Str,425			Self::Num(..) => ValType::Num,426			Self::Arr(..) => ValType::Arr,427			Self::Obj(..) => ValType::Obj,428			Self::Bool(_) => ValType::Bool,429			Self::Null => ValType::Null,430			Self::Func(..) => ValType::Func,431		}432	}433434	pub fn to_string(&self) -> Result<IStr> {435		Ok(match self {436			Self::Bool(true) => "true".into(),437			Self::Bool(false) => "false".into(),438			Self::Null => "null".into(),439			Self::Str(s) => s.clone(),440			v => manifest_json_ex(441				v,442				&ManifestJsonOptions {443					padding: "",444					mtype: ManifestType::ToString,445				},446			)?447			.into(),448		})449	}450451	/// Expects value to be object, outputs (key, manifested value) pairs452	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {453		let obj = match self {454			Self::Obj(obj) => obj,455			_ => throw!(MultiManifestOutputIsNotAObject),456		};457		let keys = obj.fields();458		let mut out = Vec::with_capacity(keys.len());459		for key in keys {460			let value = obj461				.get(key.clone())?462				.expect("item in object")463				.manifest(ty)?;464			out.push((key, value));465		}466		Ok(out)467	}468469	/// Expects value to be array, outputs manifested values470	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {471		let arr = match self {472			Self::Arr(a) => a,473			_ => throw!(StreamManifestOutputIsNotAArray),474		};475		let mut out = Vec::with_capacity(arr.len());476		for i in arr.iter() {477			out.push(i?.manifest(ty)?);478		}479		Ok(out)480	}481482	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {483		Ok(match ty {484			ManifestFormat::YamlStream(format) => {485				let arr = match self {486					Self::Arr(a) => a,487					_ => throw!(StreamManifestOutputIsNotAArray),488				};489				let mut out = String::new();490491				match format as &ManifestFormat {492					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),493					ManifestFormat::String => throw!(StreamManifestCannotNestString),494					_ => {}495				};496497				if !arr.is_empty() {498					for v in arr.iter() {499						out.push_str("---\n");500						out.push_str(&v?.manifest(format)?);501						out.push('\n');502					}503					out.push_str("...");504				}505506				out.into()507			}508			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,509			ManifestFormat::Json(padding) => self.to_json(*padding)?,510			ManifestFormat::ToString => self.to_string()?,511			ManifestFormat::String => match self {512				Self::Str(s) => s.clone(),513				_ => throw!(StringManifestOutputIsNotAString),514			},515		})516	}517518	/// For manifestification519	pub fn to_json(&self, padding: usize) -> Result<IStr> {520		manifest_json_ex(521			self,522			&ManifestJsonOptions {523				padding: &" ".repeat(padding),524				mtype: if padding == 0 {525					ManifestType::Minify526				} else {527					ManifestType::Manifest528				},529			},530		)531		.map(|s| s.into())532	}533534	/// Calls `std.manifestJson`535	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {536		manifest_json_ex(537			self,538			&ManifestJsonOptions {539				padding: &" ".repeat(padding),540				mtype: ManifestType::Std,541			},542		)543		.map(|s| s.into())544	}545546	pub fn to_yaml(&self, padding: usize) -> Result<IStr> {547		with_state(|s| {548			let ctx = s549				.create_default_context()550				.with_var("__tmp__to_json__".into(), self.clone());551			evaluate(552				ctx,553				&el!(Expr::Apply(554					el!(Expr::Index(555						el!(Expr::Var("std".into())),556						el!(Expr::Str("manifestYamlDoc".into()))557					)),558					ArgsDesc::new(559						vec![560							el!(Expr::Var("__tmp__to_json__".into())),561							el!(Expr::Literal(if padding != 0 {562								LiteralType::True563							} else {564								LiteralType::False565							})),566						],567						vec![]568					),569					false570				)),571			)?572			.try_cast_str("to json")573		})574	}575	pub fn into_indexable(self) -> Result<IndexableVal> {576		Ok(match self {577			Val::Str(s) => IndexableVal::Str(s),578			Val::Arr(arr) => IndexableVal::Arr(arr),579			_ => throw!(ValueIsNotIndexable(self.value_type())),580		})581	}582}583584const fn is_function_like(val: &Val) -> bool {585	matches!(val, Val::Func(_))586}587588/// Native implementation of `std.primitiveEquals`589pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {590	Ok(match (val_a, val_b) {591		(Val::Bool(a), Val::Bool(b)) => a == b,592		(Val::Null, Val::Null) => true,593		(Val::Str(a), Val::Str(b)) => a == b,594		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,595		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(596			"primitiveEquals operates on primitive types, got array".into(),597		)),598		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(599			"primitiveEquals operates on primitive types, got object".into(),600		)),601		(a, b) if is_function_like(a) && is_function_like(b) => {602			throw!(RuntimeError("cannot test equality of functions".into()))603		}604		(_, _) => false,605	})606}607608/// Native implementation of `std.equals`609pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {610	if val_a.value_type() != val_b.value_type() {611		return Ok(false);612	}613	match (val_a, val_b) {614		(Val::Arr(a), Val::Arr(b)) => {615			if ArrValue::ptr_eq(a, b) {616				return Ok(true);617			}618			if a.len() != b.len() {619				return Ok(false);620			}621			for (a, b) in a.iter().zip(b.iter()) {622				if !equals(&a?, &b?)? {623					return Ok(false);624				}625			}626			Ok(true)627		}628		(Val::Obj(a), Val::Obj(b)) => {629			if ObjValue::ptr_eq(a, b) {630				return Ok(true);631			}632			let fields = a.fields();633			if fields != b.fields() {634				return Ok(false);635			}636			for field in fields {637				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {638					return Ok(false);639				}640			}641			Ok(true)642		}643		(a, b) => Ok(primitive_equals(a, b)?),644	}645}