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

1use crate::{2	builtin::std_slice,3	error::Error::*,4	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},5	push, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,6	FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder, ObjectAssertion,7	Result, Val,8};9use jrsonnet_gc::{Gc, Trace};10use jrsonnet_interner::IStr;11use jrsonnet_parser::{12	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, ExprLocation, FieldMember, ForSpecData,13	IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,14};15use jrsonnet_types::ValType;16use rustc_hash::{FxHashMap, FxHasher};17use std::{collections::HashMap, hash::BuildHasherDefault};18pub mod operator;1920pub fn evaluate_binding_in_future(21	b: &BindSpec,22	context_creator: FutureWrapper<Context>,23) -> LazyVal {24	let b = b.clone();25	if let Some(params) = &b.params {26		let params = params.clone();2728		#[derive(Trace)]29		#[trivially_drop]30		struct LazyMethodBinding {31			context_creator: FutureWrapper<Context>,32			name: IStr,33			params: ParamsDesc,34			value: LocExpr,35		}36		impl LazyValValue for LazyMethodBinding {37			fn get(self: Box<Self>) -> Result<Val> {38				Ok(evaluate_method(39					self.context_creator.unwrap(),40					self.name,41					self.params,42					self.value,43				))44			}45		}4647		LazyVal::new(Box::new(LazyMethodBinding {48			context_creator,49			name: b.name.clone(),50			params,51			value: b.value.clone(),52		}))53	} else {54		#[derive(Trace)]55		#[trivially_drop]56		struct LazyNamedBinding {57			context_creator: FutureWrapper<Context>,58			name: IStr,59			value: LocExpr,60		}61		impl LazyValValue for LazyNamedBinding {62			fn get(self: Box<Self>) -> Result<Val> {63				evaluate_named(self.context_creator.unwrap(), &self.value, self.name)64			}65		}66		LazyVal::new(Box::new(LazyNamedBinding {67			context_creator,68			name: b.name.clone(),69			value: b.value,70		}))71	}72}7374pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {75	let b = b.clone();76	if let Some(params) = &b.params {77		let params = params.clone();7879		#[derive(Trace)]80		#[trivially_drop]81		struct BindableMethodLazyVal {82			this: Option<ObjValue>,83			super_obj: Option<ObjValue>,8485			context_creator: ContextCreator,86			name: IStr,87			params: ParamsDesc,88			value: LocExpr,89		}90		impl LazyValValue for BindableMethodLazyVal {91			fn get(self: Box<Self>) -> Result<Val> {92				Ok(evaluate_method(93					self.context_creator.create(self.this, self.super_obj)?,94					self.name,95					self.params,96					self.value,97				))98			}99		}100101		#[derive(Trace)]102		#[trivially_drop]103		struct BindableMethod {104			context_creator: ContextCreator,105			name: IStr,106			params: ParamsDesc,107			value: LocExpr,108		}109		impl Bindable for BindableMethod {110			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {111				Ok(LazyVal::new(Box::new(BindableMethodLazyVal {112					this,113					super_obj,114115					context_creator: self.context_creator.clone(),116					name: self.name.clone(),117					params: self.params.clone(),118					value: self.value.clone(),119				})))120			}121		}122123		(124			b.name.clone(),125			LazyBinding::Bindable(Gc::new(Box::new(BindableMethod {126				context_creator,127				name: b.name.clone(),128				params,129				value: b.value.clone(),130			}))),131		)132	} else {133		#[derive(Trace)]134		#[trivially_drop]135		struct BindableNamedLazyVal {136			this: Option<ObjValue>,137			super_obj: Option<ObjValue>,138139			context_creator: ContextCreator,140			name: IStr,141			value: LocExpr,142		}143		impl LazyValValue for BindableNamedLazyVal {144			fn get(self: Box<Self>) -> Result<Val> {145				evaluate_named(146					self.context_creator.create(self.this, self.super_obj)?,147					&self.value,148					self.name,149				)150			}151		}152153		#[derive(Trace)]154		#[trivially_drop]155		struct BindableNamed {156			context_creator: ContextCreator,157			name: IStr,158			value: LocExpr,159		}160		impl Bindable for BindableNamed {161			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {162				Ok(LazyVal::new(Box::new(BindableNamedLazyVal {163					this,164					super_obj,165166					context_creator: self.context_creator.clone(),167					name: self.name.clone(),168					value: self.value.clone(),169				})))170			}171		}172173		(174			b.name.clone(),175			LazyBinding::Bindable(Gc::new(Box::new(BindableNamed {176				context_creator,177				name: b.name.clone(),178				value: b.value.clone(),179			}))),180		)181	}182}183184pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {185	Val::Func(Gc::new(FuncVal::Normal(FuncDesc {186		name,187		ctx,188		params,189		body,190	})))191}192193pub fn evaluate_field_name(194	context: Context,195	field_name: &jrsonnet_parser::FieldName,196) -> Result<Option<IStr>> {197	Ok(match field_name {198		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),199		jrsonnet_parser::FieldName::Dyn(expr) => {200			let value = evaluate(context, expr)?;201			if matches!(value, Val::Null) {202				None203			} else {204				Some(value.try_cast_str("dynamic field name")?)205			}206		}207	})208}209210pub fn evaluate_comp(211	context: Context,212	specs: &[CompSpec],213	callback: &mut impl FnMut(Context) -> Result<()>,214) -> Result<()> {215	match specs.get(0) {216		None => callback(context)?,217		Some(CompSpec::IfSpec(IfSpecData(cond))) => {218			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {219				evaluate_comp(context, &specs[1..], callback)?220			}221		}222		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {223			Val::Arr(list) => {224				for item in list.iter() {225					evaluate_comp(226						context.clone().with_var(var.clone(), item?.clone()),227						&specs[1..],228						callback,229					)?230				}231			}232			_ => throw!(InComprehensionCanOnlyIterateOverArray),233		},234	}235	Ok(())236}237238pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {239	let new_bindings = FutureWrapper::new();240	let future_this = FutureWrapper::new();241	let context_creator = ContextCreator(context.clone(), new_bindings.clone());242	{243		let mut bindings: FxHashMap<IStr, LazyBinding> =244			FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());245		for (n, b) in members246			.iter()247			.filter_map(|m| match m {248				Member::BindStmt(b) => Some(b.clone()),249				_ => None,250			})251			.map(|b| evaluate_binding(&b, context_creator.clone()))252		{253			bindings.insert(n, b);254		}255		new_bindings.fill(bindings);256	}257258	let mut builder = ObjValueBuilder::new();259	for member in members.iter() {260		match member {261			Member::Field(FieldMember {262				name,263				plus,264				params: None,265				visibility,266				value,267			}) => {268				let name = evaluate_field_name(context.clone(), name)?;269				if name.is_none() {270					continue;271				}272				let name = name.unwrap();273274				#[derive(Trace)]275				#[trivially_drop]276				struct ObjMemberBinding {277					context_creator: ContextCreator,278					value: LocExpr,279					name: IStr,280				}281				impl Bindable for ObjMemberBinding {282					fn bind(283						&self,284						this: Option<ObjValue>,285						super_obj: Option<ObjValue>,286					) -> Result<LazyVal> {287						Ok(LazyVal::new_resolved(evaluate_named(288							self.context_creator.create(this, super_obj)?,289							&self.value,290							self.name.clone(),291						)?))292					}293				}294				builder295					.member(name.clone())296					.with_add(*plus)297					.with_visibility(*visibility)298					.with_location(value.1.clone())299					.bindable(Box::new(ObjMemberBinding {300						context_creator: context_creator.clone(),301						value: value.clone(),302						name,303					}));304			}305			Member::Field(FieldMember {306				name,307				params: Some(params),308				value,309				..310			}) => {311				let name = evaluate_field_name(context.clone(), name)?;312				if name.is_none() {313					continue;314				}315				let name = name.unwrap();316				#[derive(Trace)]317				#[trivially_drop]318				struct ObjMemberBinding {319					context_creator: ContextCreator,320					value: LocExpr,321					params: ParamsDesc,322					name: IStr,323				}324				impl Bindable for ObjMemberBinding {325					fn bind(326						&self,327						this: Option<ObjValue>,328						super_obj: Option<ObjValue>,329					) -> Result<LazyVal> {330						Ok(LazyVal::new_resolved(evaluate_method(331							self.context_creator.create(this, super_obj)?,332							self.name.clone(),333							self.params.clone(),334							self.value.clone(),335						)))336					}337				}338				builder339					.member(name.clone())340					.hide()341					.with_location(value.1.clone())342					.bindable(Box::new(ObjMemberBinding {343						context_creator: context_creator.clone(),344						value: value.clone(),345						params: params.clone(),346						name,347					}));348			}349			Member::BindStmt(_) => {}350			Member::AssertStmt(stmt) => {351				#[derive(Trace)]352				#[trivially_drop]353				struct ObjectAssert {354					context_creator: ContextCreator,355					assert: AssertStmt,356				}357				impl ObjectAssertion for ObjectAssert {358					fn run(359						&self,360						this: Option<ObjValue>,361						super_obj: Option<ObjValue>,362					) -> Result<()> {363						let ctx = self.context_creator.create(this, super_obj)?;364						evaluate_assert(ctx, &self.assert)365					}366				}367				builder.assert(Box::new(ObjectAssert {368					context_creator: context_creator.clone(),369					assert: stmt.clone(),370				}));371			}372		}373	}374	let this = builder.build();375	future_this.fill(this.clone());376	Ok(this)377}378379pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {380	Ok(match object {381		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,382		ObjBody::ObjComp(obj) => {383			let future_this = FutureWrapper::new();384			let mut builder = ObjValueBuilder::new();385			evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {386				let new_bindings = FutureWrapper::new();387				let context_creator = ContextCreator(context.clone(), new_bindings.clone());388				let mut bindings: FxHashMap<IStr, LazyBinding> =389					FxHashMap::with_capacity_and_hasher(390						obj.pre_locals.len() + obj.post_locals.len(),391						BuildHasherDefault::default(),392					);393				for (n, b) in obj394					.pre_locals395					.iter()396					.chain(obj.post_locals.iter())397					.map(|b| evaluate_binding(b, context_creator.clone()))398				{399					bindings.insert(n, b);400				}401				new_bindings.fill(bindings.clone());402				let ctx = ctx.extend_unbound(bindings, None, None, None)?;403				let key = evaluate(ctx.clone(), &obj.key)?;404405				match key {406					Val::Null => {}407					Val::Str(n) => {408						#[derive(Trace)]409						#[trivially_drop]410						struct ObjCompBinding {411							context: Context,412							value: LocExpr,413						}414						impl Bindable for ObjCompBinding {415							fn bind(416								&self,417								this: Option<ObjValue>,418								_super_obj: Option<ObjValue>,419							) -> Result<LazyVal> {420								Ok(LazyVal::new_resolved(evaluate(421									self.context.clone().extend(422										FxHashMap::default(),423										None,424										this,425										None,426									),427									&self.value,428								)?))429							}430						}431						builder432							.member(n)433							.with_location(obj.value.1.clone())434							.with_add(obj.plus)435							.bindable(Box::new(ObjCompBinding {436								context: ctx,437								value: obj.value.clone(),438							}));439					}440					v => throw!(FieldMustBeStringGot(v.value_type())),441				}442443				Ok(())444			})?;445446			let this = builder.build();447			future_this.fill(this.clone());448			this449		}450	})451}452453pub fn evaluate_apply(454	context: Context,455	value: &LocExpr,456	args: &ArgsDesc,457	loc: Option<&ExprLocation>,458	tailstrict: bool,459) -> Result<Val> {460	let value = evaluate(context.clone(), value)?;461	Ok(match value {462		Val::Func(f) => {463			let body = || f.evaluate(context, loc, args, tailstrict);464			if tailstrict {465				body()?466			} else {467				push(loc, || format!("function <{}> call", f.name()), body)?468			}469		}470		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),471	})472}473474pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {475	let value = &assertion.0;476	let msg = &assertion.1;477	let assertion_result = push(478		value.1.as_ref(),479		|| "assertion condition".to_owned(),480		|| {481			evaluate(context.clone(), value)?482				.try_cast_bool("assertion condition should be of type `boolean`")483		},484	)?;485	if !assertion_result {486		push(487			value.1.as_ref(),488			|| "assertion failure".to_owned(),489			|| {490				if let Some(msg) = msg {491					throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));492				} else {493					throw!(AssertionFailed(Val::Null.to_string()?));494				}495			},496		)?497	}498	Ok(())499}500501pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {502	use Expr::*;503	let LocExpr(expr, _loc) = lexpr;504	Ok(match &**expr {505		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),506		_ => evaluate(context, lexpr)?,507	})508}509510pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {511	use Expr::*;512	let LocExpr(expr, loc) = expr;513	Ok(match &**expr {514		Literal(LiteralType::This) => {515			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)516		}517		Literal(LiteralType::Super) => Val::Obj(518			context519				.super_obj()520				.clone()521				.ok_or(NoSuperFound)?522				.with_this(context.this().clone().unwrap()),523		),524		Literal(LiteralType::Dollar) => {525			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)526		}527		Literal(LiteralType::True) => Val::Bool(true),528		Literal(LiteralType::False) => Val::Bool(false),529		Literal(LiteralType::Null) => Val::Null,530		Parened(e) => evaluate(context, e)?,531		Str(v) => Val::Str(v.clone()),532		Num(v) => Val::new_checked_num(*v)?,533		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,534		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,535		Var(name) => push(536			loc.as_ref(),537			|| format!("variable <{}>", name),538			|| context.binding(name.clone())?.evaluate(),539		)?,540		Index(value, index) => {541			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {542				(Val::Obj(v), Val::Str(s)) => {543					let sn = s.clone();544					push(545						loc.as_ref(),546						|| format!("field <{}> access", sn),547						|| {548							if let Some(v) = v.get(s.clone())? {549								Ok(v)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		Slice(value, desc) => {683			let indexable = evaluate(context.clone(), value)?;684685			fn parse_num(686				context: &Context,687				expr: Option<&LocExpr>,688				desc: &'static str,689			) -> Result<Option<usize>> {690				Ok(match expr {691					Some(s) => evaluate(context.clone(), s)?692						.try_cast_nullable_num(desc)?693						.map(|v| v as usize),694					None => None,695				})696			}697698			let start = parse_num(&context, desc.start.as_ref(), "start")?;699			let end = parse_num(&context, desc.end.as_ref(), "end")?;700			let step = parse_num(&context, desc.step.as_ref(), "step")?;701702			std_slice(indexable.into_indexable()?, start, end, step)?703		}704		Import(path) => {705			let tmp = loc706				.clone()707				.expect("imports cannot be used without loc_data")708				.0;709			let mut import_location = tmp.to_path_buf();710			import_location.pop();711			push(712				loc.as_ref(),713				|| format!("import {:?}", path),714				|| with_state(|s| s.import_file(&import_location, path)),715			)?716		}717		ImportStr(path) => {718			let tmp = loc719				.clone()720				.expect("imports cannot be used without loc_data")721				.0;722			let mut import_location = tmp.to_path_buf();723			import_location.pop();724			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)725		}726	})727}