git.delta.rocks / jrsonnet / refs/commits / 0b0d703c6d05

1use crate::{2	error::Error::*,3	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},4	push, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,5	FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder, ObjectAssertion,6	Result, Val,7};8use jrsonnet_gc::{Gc, Trace};9use jrsonnet_interner::IStr;10use jrsonnet_parser::{11	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, ExprLocation, FieldMember, ForSpecData,12	IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,13};14use jrsonnet_types::ValType;15use rustc_hash::{FxHashMap, FxHasher};16use std::{collections::HashMap, hash::BuildHasherDefault};17pub mod operator;1819pub fn evaluate_binding_in_future(20	b: &BindSpec,21	context_creator: FutureWrapper<Context>,22) -> LazyVal {23	let b = b.clone();24	if let Some(params) = &b.params {25		let params = params.clone();2627		#[derive(Trace)]28		#[trivially_drop]29		struct LazyMethodBinding {30			context_creator: FutureWrapper<Context>,31			name: IStr,32			params: ParamsDesc,33			value: LocExpr,34		}35		impl LazyValValue for LazyMethodBinding {36			fn get(self: Box<Self>) -> Result<Val> {37				Ok(evaluate_method(38					self.context_creator.unwrap(),39					self.name,40					self.params,41					self.value,42				))43			}44		}4546		LazyVal::new(Box::new(LazyMethodBinding {47			context_creator,48			name: b.name.clone(),49			params,50			value: b.value.clone(),51		}))52	} else {53		#[derive(Trace)]54		#[trivially_drop]55		struct LazyNamedBinding {56			context_creator: FutureWrapper<Context>,57			name: IStr,58			value: LocExpr,59		}60		impl LazyValValue for LazyNamedBinding {61			fn get(self: Box<Self>) -> Result<Val> {62				evaluate_named(self.context_creator.unwrap(), &self.value, self.name)63			}64		}65		LazyVal::new(Box::new(LazyNamedBinding {66			context_creator,67			name: b.name.clone(),68			value: b.value,69		}))70	}71}7273pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {74	let b = b.clone();75	if let Some(params) = &b.params {76		let params = params.clone();7778		#[derive(Trace)]79		#[trivially_drop]80		struct BindableMethodLazyVal {81			this: Option<ObjValue>,82			super_obj: Option<ObjValue>,8384			context_creator: ContextCreator,85			name: IStr,86			params: ParamsDesc,87			value: LocExpr,88		}89		impl LazyValValue for BindableMethodLazyVal {90			fn get(self: Box<Self>) -> Result<Val> {91				Ok(evaluate_method(92					self.context_creator.create(self.this, self.super_obj)?,93					self.name,94					self.params,95					self.value,96				))97			}98		}99100		#[derive(Trace)]101		#[trivially_drop]102		struct BindableMethod {103			context_creator: ContextCreator,104			name: IStr,105			params: ParamsDesc,106			value: LocExpr,107		}108		impl Bindable for BindableMethod {109			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {110				Ok(LazyVal::new(Box::new(BindableMethodLazyVal {111					this,112					super_obj,113114					context_creator: self.context_creator.clone(),115					name: self.name.clone(),116					params: self.params.clone(),117					value: self.value.clone(),118				})))119			}120		}121122		(123			b.name.clone(),124			LazyBinding::Bindable(Gc::new(Box::new(BindableMethod {125				context_creator,126				name: b.name.clone(),127				params,128				value: b.value.clone(),129			}))),130		)131	} else {132		#[derive(Trace)]133		#[trivially_drop]134		struct BindableNamedLazyVal {135			this: Option<ObjValue>,136			super_obj: Option<ObjValue>,137138			context_creator: ContextCreator,139			name: IStr,140			value: LocExpr,141		}142		impl LazyValValue for BindableNamedLazyVal {143			fn get(self: Box<Self>) -> Result<Val> {144				evaluate_named(145					self.context_creator.create(self.this, self.super_obj)?,146					&self.value,147					self.name,148				)149			}150		}151152		#[derive(Trace)]153		#[trivially_drop]154		struct BindableNamed {155			context_creator: ContextCreator,156			name: IStr,157			value: LocExpr,158		}159		impl Bindable for BindableNamed {160			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {161				Ok(LazyVal::new(Box::new(BindableNamedLazyVal {162					this,163					super_obj,164165					context_creator: self.context_creator.clone(),166					name: self.name.clone(),167					value: self.value.clone(),168				})))169			}170		}171172		(173			b.name.clone(),174			LazyBinding::Bindable(Gc::new(Box::new(BindableNamed {175				context_creator,176				name: b.name.clone(),177				value: b.value.clone(),178			}))),179		)180	}181}182183pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {184	Val::Func(Gc::new(FuncVal::Normal(FuncDesc {185		name,186		ctx,187		params,188		body,189	})))190}191192pub fn evaluate_field_name(193	context: Context,194	field_name: &jrsonnet_parser::FieldName,195) -> Result<Option<IStr>> {196	Ok(match field_name {197		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),198		jrsonnet_parser::FieldName::Dyn(expr) => {199			let value = evaluate(context, expr)?;200			if matches!(value, Val::Null) {201				None202			} else {203				Some(value.try_cast_str("dynamic field name")?)204			}205		}206	})207}208209pub fn evaluate_comp(210	context: Context,211	specs: &[CompSpec],212	callback: &mut impl FnMut(Context) -> Result<()>,213) -> Result<()> {214	match specs.get(0) {215		None => callback(context)?,216		Some(CompSpec::IfSpec(IfSpecData(cond))) => {217			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {218				evaluate_comp(context, &specs[1..], callback)?219			}220		}221		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {222			Val::Arr(list) => {223				for item in list.iter() {224					evaluate_comp(225						context.clone().with_var(var.clone(), item?.clone()),226						&specs[1..],227						callback,228					)?229				}230			}231			_ => throw!(InComprehensionCanOnlyIterateOverArray),232		},233	}234	Ok(())235}236237pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {238	let new_bindings = FutureWrapper::new();239	let future_this = FutureWrapper::new();240	let context_creator = ContextCreator(context.clone(), new_bindings.clone());241	{242		let mut bindings: FxHashMap<IStr, LazyBinding> =243			FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());244		for (n, b) in members245			.iter()246			.filter_map(|m| match m {247				Member::BindStmt(b) => Some(b.clone()),248				_ => None,249			})250			.map(|b| evaluate_binding(&b, context_creator.clone()))251		{252			bindings.insert(n, b);253		}254		new_bindings.fill(bindings);255	}256257	let mut builder = ObjValueBuilder::new();258	for member in members.iter() {259		match member {260			Member::Field(FieldMember {261				name,262				plus,263				params: None,264				visibility,265				value,266			}) => {267				let name = evaluate_field_name(context.clone(), name)?;268				if name.is_none() {269					continue;270				}271				let name = name.unwrap();272273				#[derive(Trace)]274				#[trivially_drop]275				struct ObjMemberBinding {276					context_creator: ContextCreator,277					value: LocExpr,278					name: IStr,279				}280				impl Bindable for ObjMemberBinding {281					fn bind(282						&self,283						this: Option<ObjValue>,284						super_obj: Option<ObjValue>,285					) -> Result<LazyVal> {286						Ok(LazyVal::new_resolved(evaluate_named(287							self.context_creator.create(this, super_obj)?,288							&self.value,289							self.name.clone(),290						)?))291					}292				}293				builder294					.member(name.clone())295					.with_add(*plus)296					.with_visibility(*visibility)297					.with_location(value.1.clone())298					.bindable(Box::new(ObjMemberBinding {299						context_creator: context_creator.clone(),300						value: value.clone(),301						name,302					}));303			}304			Member::Field(FieldMember {305				name,306				params: Some(params),307				value,308				..309			}) => {310				let name = evaluate_field_name(context.clone(), name)?;311				if name.is_none() {312					continue;313				}314				let name = name.unwrap();315				#[derive(Trace)]316				#[trivially_drop]317				struct ObjMemberBinding {318					context_creator: ContextCreator,319					value: LocExpr,320					params: ParamsDesc,321					name: IStr,322				}323				impl Bindable for ObjMemberBinding {324					fn bind(325						&self,326						this: Option<ObjValue>,327						super_obj: Option<ObjValue>,328					) -> Result<LazyVal> {329						Ok(LazyVal::new_resolved(evaluate_method(330							self.context_creator.create(this, super_obj)?,331							self.name.clone(),332							self.params.clone(),333							self.value.clone(),334						)))335					}336				}337				builder338					.member(name.clone())339					.hide()340					.with_location(value.1.clone())341					.binding(LazyBinding::Bindable(Gc::new(Box::new(ObjMemberBinding {342						context_creator: context_creator.clone(),343						value: value.clone(),344						params: params.clone(),345						name,346					}))));347			}348			Member::BindStmt(_) => {}349			Member::AssertStmt(stmt) => {350				#[derive(Trace)]351				#[trivially_drop]352				struct ObjectAssert {353					context_creator: ContextCreator,354					assert: AssertStmt,355				}356				impl ObjectAssertion for ObjectAssert {357					fn run(358						&self,359						this: Option<ObjValue>,360						super_obj: Option<ObjValue>,361					) -> Result<()> {362						let ctx = self.context_creator.create(this, super_obj)?;363						evaluate_assert(ctx, &self.assert)364					}365				}366				builder.assert(Box::new(ObjectAssert {367					context_creator: context_creator.clone(),368					assert: stmt.clone(),369				}));370			}371		}372	}373	let this = builder.build();374	future_this.fill(this.clone());375	Ok(this)376}377378pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {379	Ok(match object {380		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,381		ObjBody::ObjComp(obj) => {382			let future_this = FutureWrapper::new();383			let mut builder = ObjValueBuilder::new();384			evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {385				let new_bindings = FutureWrapper::new();386				let context_creator = ContextCreator(context.clone(), new_bindings.clone());387				let mut bindings: FxHashMap<IStr, LazyBinding> =388					FxHashMap::with_capacity_and_hasher(389						obj.pre_locals.len() + obj.post_locals.len(),390						BuildHasherDefault::default(),391					);392				for (n, b) in obj393					.pre_locals394					.iter()395					.chain(obj.post_locals.iter())396					.map(|b| evaluate_binding(b, context_creator.clone()))397				{398					bindings.insert(n, b);399				}400				new_bindings.fill(bindings.clone());401				let ctx = ctx.extend_unbound(bindings, None, None, None)?;402				let key = evaluate(ctx.clone(), &obj.key)?;403404				match key {405					Val::Null => {}406					Val::Str(n) => {407						#[derive(Trace)]408						#[trivially_drop]409						struct ObjCompBinding {410							context: Context,411							value: LocExpr,412						}413						impl Bindable for ObjCompBinding {414							fn bind(415								&self,416								this: Option<ObjValue>,417								_super_obj: Option<ObjValue>,418							) -> Result<LazyVal> {419								Ok(LazyVal::new_resolved(evaluate(420									self.context.clone().extend(421										FxHashMap::default(),422										None,423										this,424										None,425									),426									&self.value,427								)?))428							}429						}430						builder431							.member(n)432							.with_location(obj.value.1.clone())433							.bindable(Box::new(ObjCompBinding {434								context: ctx,435								value: obj.value.clone(),436							}));437					}438					v => throw!(FieldMustBeStringGot(v.value_type())),439				}440441				Ok(())442			})?;443444			let this = builder.build();445			future_this.fill(this.clone());446			this447		}448	})449}450451pub fn evaluate_apply(452	context: Context,453	value: &LocExpr,454	args: &ArgsDesc,455	loc: Option<&ExprLocation>,456	tailstrict: bool,457) -> Result<Val> {458	let value = evaluate(context.clone(), value)?;459	Ok(match value {460		Val::Func(f) => {461			let body = || f.evaluate(context, loc, args, tailstrict);462			if tailstrict {463				body()?464			} else {465				push(loc, || format!("function <{}> call", f.name()), body)?466			}467		}468		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),469	})470}471472pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {473	let value = &assertion.0;474	let msg = &assertion.1;475	let assertion_result = push(476		value.1.as_ref(),477		|| "assertion condition".to_owned(),478		|| {479			evaluate(context.clone(), value)?480				.try_cast_bool("assertion condition should be of type `boolean`")481		},482	)?;483	if !assertion_result {484		push(485			value.1.as_ref(),486			|| "assertion failure".to_owned(),487			|| {488				if let Some(msg) = msg {489					throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));490				} else {491					throw!(AssertionFailed(Val::Null.to_string()?));492				}493			},494		)?495	}496	Ok(())497}498499pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {500	use Expr::*;501	let LocExpr(expr, _loc) = lexpr;502	Ok(match &**expr {503		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),504		_ => evaluate(context, lexpr)?,505	})506}507508pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {509	use Expr::*;510	let LocExpr(expr, loc) = expr;511	Ok(match &**expr {512		Literal(LiteralType::This) => {513			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)514		}515		Literal(LiteralType::Super) => Val::Obj(516			context517				.super_obj()518				.clone()519				.ok_or(NoSuperFound)?520				.with_this(context.this().clone().unwrap()),521		),522		Literal(LiteralType::Dollar) => {523			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)524		}525		Literal(LiteralType::True) => Val::Bool(true),526		Literal(LiteralType::False) => Val::Bool(false),527		Literal(LiteralType::Null) => Val::Null,528		Parened(e) => evaluate(context, e)?,529		Str(v) => Val::Str(v.clone()),530		Num(v) => Val::new_checked_num(*v)?,531		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,532		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,533		Var(name) => push(534			loc.as_ref(),535			|| format!("variable <{}>", name),536			|| context.binding(name.clone())?.evaluate(),537		)?,538		Index(value, index) => {539			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {540				(Val::Obj(v), Val::Str(s)) => {541					let sn = s.clone();542					push(543						loc.as_ref(),544						|| format!("field <{}> access", sn),545						|| {546							if let Some(v) = v.get(s.clone())? {547								Ok(v)548							} else if v.get("__intrinsic_namespace__".into())?.is_some() {549								Ok(Val::Func(Gc::new(FuncVal::Intrinsic(s))))550							} else {551								throw!(NoSuchField(s))552							}553						},554					)?555				}556				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(557					ValType::Obj,558					ValType::Str,559					n.value_type(),560				)),561562				(Val::Arr(v), Val::Num(n)) => {563					if n.fract() > f64::EPSILON {564						throw!(FractionalIndex)565					}566					v.get(n as usize)?567						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?568				}569				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),570				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(571					ValType::Arr,572					ValType::Num,573					n.value_type(),574				)),575576				(Val::Str(s), Val::Num(n)) => Val::Str(577					s.chars()578						.skip(n as usize)579						.take(1)580						.collect::<String>()581						.into(),582				),583				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(584					ValType::Str,585					ValType::Num,586					n.value_type(),587				)),588589				(v, _) => throw!(CantIndexInto(v.value_type())),590			}591		}592		LocalExpr(bindings, returned) => {593			let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(594				bindings.len(),595				BuildHasherDefault::<FxHasher>::default(),596			);597			let future_context = Context::new_future();598			for b in bindings {599				new_bindings.insert(600					b.name.clone(),601					evaluate_binding_in_future(b, future_context.clone()),602				);603			}604			let context = context605				.extend_bound(new_bindings)606				.into_future(future_context);607			evaluate(context, &returned.clone())?608		}609		Arr(items) => {610			let mut out = Vec::with_capacity(items.len());611			for item in items {612				// TODO: Implement ArrValue::Lazy with same context for every element?613				#[derive(Trace)]614				#[trivially_drop]615				struct ArrayElement {616					context: Context,617					item: LocExpr,618				}619				impl LazyValValue for ArrayElement {620					fn get(self: Box<Self>) -> Result<Val> {621						evaluate(self.context, &self.item)622					}623				}624				out.push(LazyVal::new(Box::new(ArrayElement {625					context: context.clone(),626					item: item.clone(),627				})));628			}629			Val::Arr(out.into())630		}631		ArrComp(expr, comp_specs) => {632			let mut out = Vec::new();633			evaluate_comp(context, comp_specs, &mut |ctx| {634				out.push(evaluate(ctx, expr)?);635				Ok(())636			})?;637			Val::Arr(ArrValue::Eager(Gc::new(out)))638		}639		Obj(body) => Val::Obj(evaluate_object(context, body)?),640		ObjExtend(s, t) => evaluate_add_op(641			&evaluate(context.clone(), s)?,642			&Val::Obj(evaluate_object(context, t)?),643		)?,644		Apply(value, args, tailstrict) => {645			evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?646		}647		Function(params, body) => {648			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())649		}650		Intrinsic(name) => Val::Func(Gc::new(FuncVal::Intrinsic(name.clone()))),651		AssertExpr(assert, returned) => {652			evaluate_assert(context.clone(), assert)?;653			evaluate(context, returned)?654		}655		ErrorStmt(e) => push(656			loc.as_ref(),657			|| "error statement".to_owned(),658			|| {659				throw!(RuntimeError(660					evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,661				))662			},663		)?,664		IfElse {665			cond,666			cond_then,667			cond_else,668		} => {669			if push(670				loc.as_ref(),671				|| "if condition".to_owned(),672				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),673			)? {674				evaluate(context, cond_then)?675			} else {676				match cond_else {677					Some(v) => evaluate(context, v)?,678					None => Val::Null,679				}680			}681		}682		Import(path) => {683			let tmp = loc684				.clone()685				.expect("imports cannot be used without loc_data")686				.0;687			let mut import_location = tmp.to_path_buf();688			import_location.pop();689			push(690				loc.as_ref(),691				|| format!("import {:?}", path),692				|| with_state(|s| s.import_file(&import_location, path)),693			)?694		}695		ImportStr(path) => {696			let tmp = loc697				.clone()698				.expect("imports cannot be used without loc_data")699				.0;700			let mut import_location = tmp.to_path_buf();701			import_location.pop();702			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)703		}704	})705}