git.delta.rocks / jrsonnet / refs/commits / 8d08861d28f9

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::{Finalize, Gc, GcCell, Trace};13use jrsonnet_interner::IStr;14use jrsonnet_parser::{el, Arg, 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					Some(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 = parse_function_call(call_ctx, None, &handler.params, args, true)?;140				let mut out_args = Vec::with_capacity(handler.params.len());141				for p in handler.params.0.iter() {142					out_args.push(args.binding(p.0.clone())?.evaluate()?);143				}144				Ok(handler.call(loc.map(|l| l.0.clone()), &out_args)?)145			}146		}147	}148149	pub fn evaluate_map(150		&self,151		call_ctx: Context,152		args: &HashMap<IStr, Val>,153		tailstrict: bool,154	) -> Result<Val> {155		match self {156			Self::Normal(func) => {157				let ctx = parse_function_call_map(158					call_ctx,159					Some(func.ctx.clone()),160					&func.params,161					args,162					tailstrict,163				)?;164				evaluate(ctx, &func.body)165			}166			Self::Intrinsic(_) => todo!(),167			Self::NativeExt(_, _) => todo!(),168		}169	}170171	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {172		match self {173			Self::Normal(func) => {174				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;175				evaluate(ctx, &func.body)176			}177			Self::Intrinsic(_) => todo!(),178			Self::NativeExt(_, _) => todo!(),179		}180	}181}182183#[derive(Clone)]184pub enum ManifestFormat {185	YamlStream(Box<ManifestFormat>),186	Yaml(usize),187	Json(usize),188	ToString,189	String,190}191192#[derive(Debug, Clone, Trace)]193#[trivially_drop]194pub enum ArrValue {195	Lazy(Gc<Vec<LazyVal>>),196	Eager(Gc<Vec<Val>>),197	Extended(Box<(Self, Self)>),198}199impl ArrValue {200	pub fn new_eager() -> Self {201		Self::Eager(Gc::new(Vec::new()))202	}203204	pub fn len(&self) -> usize {205		match self {206			Self::Lazy(l) => l.len(),207			Self::Eager(e) => e.len(),208			Self::Extended(v) => v.0.len() + v.1.len(),209		}210	}211212	pub fn is_empty(&self) -> bool {213		self.len() == 0214	}215216	pub fn get(&self, index: usize) -> Result<Option<Val>> {217		match self {218			Self::Lazy(vec) => {219				if let Some(v) = vec.get(index) {220					Ok(Some(v.evaluate()?))221				} else {222					Ok(None)223				}224			}225			Self::Eager(vec) => Ok(vec.get(index).cloned()),226			Self::Extended(v) => {227				let a_len = v.0.len();228				if a_len > index {229					v.0.get(index)230				} else {231					v.1.get(index - a_len)232				}233			}234		}235	}236237	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {238		match self {239			Self::Lazy(vec) => vec.get(index).cloned(),240			Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),241			Self::Extended(v) => {242				let a_len = v.0.len();243				if a_len > index {244					v.0.get_lazy(index)245				} else {246					v.1.get_lazy(index - a_len)247				}248			}249		}250	}251252	pub fn evaluated(&self) -> Result<Gc<Vec<Val>>> {253		Ok(match self {254			Self::Lazy(vec) => {255				let mut out = Vec::with_capacity(vec.len());256				for item in vec.iter() {257					out.push(item.evaluate()?);258				}259				Gc::new(out)260			}261			Self::Eager(vec) => vec.clone(),262			Self::Extended(_v) => {263				let mut out = Vec::with_capacity(self.len());264				for item in self.iter() {265					out.push(item?);266				}267				Gc::new(out)268			}269		})270	}271272	pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {273		(0..self.len()).map(move |idx| match self {274			Self::Lazy(l) => l[idx].evaluate(),275			Self::Eager(e) => Ok(e[idx].clone()),276			Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),277		})278	}279280	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {281		(0..self.len()).map(move |idx| match self {282			Self::Lazy(l) => l[idx].clone(),283			Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),284			Self::Extended(_) => self.get_lazy(idx).unwrap(),285		})286	}287288	pub fn reversed(self) -> Self {289		match self {290			Self::Lazy(vec) => {291				let mut out = (&vec as &Vec<_>).clone();292				out.reverse();293				Self::Lazy(Gc::new(out))294			}295			Self::Eager(vec) => {296				let mut out = (&vec as &Vec<_>).clone();297				out.reverse();298				Self::Eager(Gc::new(out))299			}300			Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),301		}302	}303304	pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {305		let mut out = Vec::with_capacity(self.len());306307		for value in self.iter() {308			out.push(mapper(value?)?);309		}310311		Ok(Self::Eager(Gc::new(out)))312	}313314	pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {315		let mut out = Vec::with_capacity(self.len());316317		for value in self.iter() {318			let value = value?;319			if filter(&value)? {320				out.push(value);321			}322		}323324		Ok(Self::Eager(Gc::new(out)))325	}326327	pub fn ptr_eq(a: &Self, b: &Self) -> bool {328		match (a, b) {329			(Self::Lazy(a), Self::Lazy(b)) => Gc::ptr_eq(a, b),330			(Self::Eager(a), Self::Eager(b)) => Gc::ptr_eq(a, b),331			_ => false,332		}333	}334}335336impl From<Vec<LazyVal>> for ArrValue {337	fn from(v: Vec<LazyVal>) -> Self {338		Self::Lazy(Gc::new(v))339	}340}341342impl From<Vec<Val>> for ArrValue {343	fn from(v: Vec<Val>) -> Self {344		Self::Eager(Gc::new(v))345	}346}347348#[derive(Debug)]349pub struct DebugGcTraceValue {350	name: IStr,351	pub value: Box<Val>,352}353impl DebugGcTraceValue {354	fn print(&self, action: &str) {355		println!("{} {}#{:?}", action, self.name, &*self.value as *const _)356	}357}358impl Finalize for DebugGcTraceValue {359	fn finalize(&self) {360		self.print("Garbage-collecting")361	}362}363impl Drop for DebugGcTraceValue {364	fn drop(&mut self) {365		self.print("Garbage-collected")366	}367}368unsafe impl Trace for DebugGcTraceValue {369	unsafe fn trace(&self) {370		self.print("Traced");371		self.value.trace()372	}373	unsafe fn root(&self) {374		self.print("Rooted");375		self.value.root()376	}377	unsafe fn unroot(&self) {378		self.print("Unrooted");379		self.value.unroot()380	}381	fn finalize_glue(&self) {382		Finalize::finalize(self)383	}384}385impl Clone for DebugGcTraceValue {386	fn clone(&self) -> Self {387		self.print("Cloned");388		let value = Self {389			name: self.name.clone(),390			value: self.value.clone(),391		};392		value.print("I'm clone");393		value394	}395}396impl DebugGcTraceValue {397	pub fn create(name: IStr, value: Val) -> Val {398		let value = Self {399			name,400			value: Box::new(value),401		};402		value.print("Constructed");403		Val::DebugGcTraceValue(value)404	}405}406407#[derive(Debug, Clone, Trace)]408#[trivially_drop]409pub enum Val {410	Bool(bool),411	Null,412	Str(IStr),413	Num(f64),414	Arr(ArrValue),415	Obj(ObjValue),416	Func(Gc<FuncVal>),417	DebugGcTraceValue(DebugGcTraceValue),418}419420macro_rules! matches_unwrap {421	($e: expr, $p: pat, $r: expr) => {422		match $e {423			$p => $r,424			_ => panic!("no match"),425		}426	};427}428impl Val {429	/// Creates `Val::Num` after checking for numeric overflow.430	/// As numbers are `f64`, we can just check for their finity.431	pub fn new_checked_num(num: f64) -> Result<Self> {432		if num.is_finite() {433			Ok(Self::Num(num))434		} else {435			throw!(RuntimeError("overflow".into()))436		}437	}438439	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {440		let this_type = self.value_type();441		if this_type != val_type {442			throw!(TypeMismatch(context, vec![val_type], this_type))443		} else {444			Ok(())445		}446	}447	pub fn unwrap_num(self) -> Result<f64> {448		Ok(matches_unwrap!(self, Self::Num(v), v))449	}450	pub fn unwrap_func(self) -> Result<Gc<FuncVal>> {451		Ok(matches_unwrap!(self, Self::Func(v), v))452	}453	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {454		self.assert_type(context, ValType::Bool)?;455		Ok(matches_unwrap!(self, Self::Bool(v), v))456	}457	pub fn try_cast_str(self, context: &'static str) -> Result<IStr> {458		self.assert_type(context, ValType::Str)?;459		Ok(matches_unwrap!(self, Self::Str(v), v))460	}461	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {462		self.assert_type(context, ValType::Num)?;463		self.unwrap_num()464	}465	pub const fn value_type(&self) -> ValType {466		match self {467			Self::Str(..) => ValType::Str,468			Self::Num(..) => ValType::Num,469			Self::Arr(..) => ValType::Arr,470			Self::Obj(..) => ValType::Obj,471			Self::Bool(_) => ValType::Bool,472			Self::Null => ValType::Null,473			Self::Func(..) => ValType::Func,474			Self::DebugGcTraceValue(v) => v.value.value_type(),475		}476	}477478	pub fn to_string(&self) -> Result<IStr> {479		Ok(match self {480			Self::Bool(true) => "true".into(),481			Self::Bool(false) => "false".into(),482			Self::Null => "null".into(),483			Self::Str(s) => s.clone(),484			v => manifest_json_ex(485				v,486				&ManifestJsonOptions {487					padding: "",488					mtype: ManifestType::ToString,489				},490			)?491			.into(),492		})493	}494495	/// Expects value to be object, outputs (key, manifested value) pairs496	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {497		let obj = match self {498			Self::Obj(obj) => obj,499			_ => throw!(MultiManifestOutputIsNotAObject),500		};501		let keys = obj.fields();502		let mut out = Vec::with_capacity(keys.len());503		for key in keys {504			let value = obj505				.get(key.clone())?506				.expect("item in object")507				.manifest(ty)?;508			out.push((key, value));509		}510		Ok(out)511	}512513	/// Expects value to be array, outputs manifested values514	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {515		let arr = match self {516			Self::Arr(a) => a,517			_ => throw!(StreamManifestOutputIsNotAArray),518		};519		let mut out = Vec::with_capacity(arr.len());520		for i in arr.iter() {521			out.push(i?.manifest(ty)?);522		}523		Ok(out)524	}525526	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {527		Ok(match ty {528			ManifestFormat::YamlStream(format) => {529				let arr = match self {530					Self::Arr(a) => a,531					_ => throw!(StreamManifestOutputIsNotAArray),532				};533				let mut out = String::new();534535				match format as &ManifestFormat {536					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),537					ManifestFormat::String => throw!(StreamManifestCannotNestString),538					_ => {}539				};540541				if !arr.is_empty() {542					for v in arr.iter() {543						out.push_str("---\n");544						out.push_str(&v?.manifest(format)?);545						out.push('\n');546					}547					out.push_str("...");548				}549550				out.into()551			}552			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,553			ManifestFormat::Json(padding) => self.to_json(*padding)?,554			ManifestFormat::ToString => self.to_string()?,555			ManifestFormat::String => match self {556				Self::Str(s) => s.clone(),557				_ => throw!(StringManifestOutputIsNotAString),558			},559		})560	}561562	/// For manifestification563	pub fn to_json(&self, padding: usize) -> Result<IStr> {564		manifest_json_ex(565			self,566			&ManifestJsonOptions {567				padding: &" ".repeat(padding),568				mtype: if padding == 0 {569					ManifestType::Minify570				} else {571					ManifestType::Manifest572				},573			},574		)575		.map(|s| s.into())576	}577578	/// Calls `std.manifestJson`579	#[cfg(feature = "faster")]580	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {581		manifest_json_ex(582			self,583			&ManifestJsonOptions {584				padding: &" ".repeat(padding),585				mtype: ManifestType::Std,586			},587		)588		.map(|s| s.into())589	}590591	/// Calls `std.manifestJson`592	#[cfg(not(feature = "faster"))]593	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {594		with_state(|s| {595			let ctx = s596				.create_default_context()?597				.with_var("__tmp__to_json__".into(), self.clone())?;598			Ok(evaluate(599				ctx,600				&el!(Expr::Apply(601					el!(Expr::Index(602						el!(Expr::Var("std".into())),603						el!(Expr::Str("manifestJsonEx".into()))604					)),605					ArgsDesc(vec![606						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),607						Arg(None, el!(Expr::Str(" ".repeat(padding).into())))608					]),609					false610				)),611			)?612			.try_cast_str("to json")?)613		})614	}615	pub fn to_yaml(&self, padding: usize) -> Result<IStr> {616		with_state(|s| {617			let ctx = s618				.create_default_context()619				.with_var("__tmp__to_json__".into(), self.clone());620			evaluate(621				ctx,622				&el!(Expr::Apply(623					el!(Expr::Index(624						el!(Expr::Var("std".into())),625						el!(Expr::Str("manifestYamlDoc".into()))626					)),627					ArgsDesc(vec![628						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),629						Arg(630							None,631							el!(Expr::Literal(if padding != 0 {632								LiteralType::True633							} else {634								LiteralType::False635							}))636						)637					]),638					false639				)),640			)?641			.try_cast_str("to json")642		})643	}644}645646const fn is_function_like(val: &Val) -> bool {647	matches!(val, Val::Func(_))648}649650/// Native implementation of `std.primitiveEquals`651pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {652	Ok(match (val_a, val_b) {653		(Val::Bool(a), Val::Bool(b)) => a == b,654		(Val::Null, Val::Null) => true,655		(Val::Str(a), Val::Str(b)) => a == b,656		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,657		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(658			"primitiveEquals operates on primitive types, got array".into(),659		)),660		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(661			"primitiveEquals operates on primitive types, got object".into(),662		)),663		(a, b) if is_function_like(a) && is_function_like(b) => {664			throw!(RuntimeError("cannot test equality of functions".into()))665		}666		(_, _) => false,667	})668}669670/// Native implementation of `std.equals`671pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {672	if val_a.value_type() != val_b.value_type() {673		return Ok(false);674	}675	match (val_a, val_b) {676		(Val::Arr(a), Val::Arr(b)) => {677			if ArrValue::ptr_eq(a, b) {678				return Ok(true);679			}680			if a.len() != b.len() {681				return Ok(false);682			}683			for (a, b) in a.iter().zip(b.iter()) {684				if !equals(&a?, &b?)? {685					return Ok(false);686				}687			}688			Ok(true)689		}690		(Val::Obj(a), Val::Obj(b)) => {691			if ObjValue::ptr_eq(a, b) {692				return Ok(true);693			}694			let fields = a.fields();695			if fields != b.fields() {696				return Ok(false);697			}698			for field in fields {699				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {700					return Ok(false);701				}702			}703			Ok(true)704		}705		(a, b) => Ok(primitive_equals(a, b)?),706	}707}