git.delta.rocks / jrsonnet / refs/commits / 349c41065b93

1use std::convert::TryFrom;23use crate::{4	builtin::{std_slice, BUILTINS},5	error::Error::*,6	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},7	function::CallLocation,8	gc::TraceBox,9	push_frame, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,10	FutureWrapper, GcHashMap, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder,11	ObjectAssertion, Result, Val,12};13use gcmodule::{Cc, Trace};14use jrsonnet_interner::IStr;15use jrsonnet_parser::{16	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, ForSpecData, IfSpecData,17	LiteralType, LocExpr, Member, ObjBody, ParamsDesc,18};19use jrsonnet_types::ValType;20pub mod operator;2122pub fn evaluate_binding_in_future(23	b: &BindSpec,24	context_creator: FutureWrapper<Context>,25) -> LazyVal {26	let b = b.clone();27	if let Some(params) = &b.params {28		let params = params.clone();2930		#[derive(Trace)]31		struct LazyMethodBinding {32			context_creator: FutureWrapper<Context>,33			name: IStr,34			params: ParamsDesc,35			value: LocExpr,36		}37		impl LazyValValue for LazyMethodBinding {38			fn get(self: Box<Self>) -> Result<Val> {39				Ok(evaluate_method(40					self.context_creator.unwrap(),41					self.name,42					self.params,43					self.value,44				))45			}46		}4748		LazyVal::new(TraceBox(Box::new(LazyMethodBinding {49			context_creator,50			name: b.name.clone(),51			params,52			value: b.value.clone(),53		})))54	} else {55		#[derive(Trace)]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(TraceBox(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		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		struct BindableMethod {102			context_creator: ContextCreator,103			name: IStr,104			params: ParamsDesc,105			value: LocExpr,106		}107		impl Bindable for BindableMethod {108			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {109				Ok(LazyVal::new(TraceBox(Box::new(BindableMethodLazyVal {110					this,111					super_obj,112113					context_creator: self.context_creator.clone(),114					name: self.name.clone(),115					params: self.params.clone(),116					value: self.value.clone(),117				}))))118			}119		}120121		(122			b.name.clone(),123			LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableMethod {124				context_creator,125				name: b.name.clone(),126				params,127				value: b.value.clone(),128			})))),129		)130	} else {131		#[derive(Trace)]132		struct BindableNamedLazyVal {133			this: Option<ObjValue>,134			super_obj: Option<ObjValue>,135136			context_creator: ContextCreator,137			name: IStr,138			value: LocExpr,139		}140		impl LazyValValue for BindableNamedLazyVal {141			fn get(self: Box<Self>) -> Result<Val> {142				evaluate_named(143					self.context_creator.create(self.this, self.super_obj)?,144					&self.value,145					self.name,146				)147			}148		}149150		#[derive(Trace)]151		struct BindableNamed {152			context_creator: ContextCreator,153			name: IStr,154			value: LocExpr,155		}156		impl Bindable for BindableNamed {157			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {158				Ok(LazyVal::new(TraceBox(Box::new(BindableNamedLazyVal {159					this,160					super_obj,161162					context_creator: self.context_creator.clone(),163					name: self.name.clone(),164					value: self.value.clone(),165				}))))166			}167		}168169		(170			b.name.clone(),171			LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableNamed {172				context_creator,173				name: b.name.clone(),174				value: b.value.clone(),175			})))),176		)177	}178}179180pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {181	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {182		name,183		ctx,184		params,185		body,186	})))187}188189pub fn evaluate_field_name(190	context: Context,191	field_name: &jrsonnet_parser::FieldName,192) -> Result<Option<IStr>> {193	Ok(match field_name {194		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),195		jrsonnet_parser::FieldName::Dyn(expr) => push_frame(196			CallLocation::new(&expr.1),197			|| "evaluating field name".to_string(),198			|| {199				let value = evaluate(context, expr)?;200				if matches!(value, Val::Null) {201					Ok(None)202				} else {203					Ok(Some(IStr::try_from(value)?))204				}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 bool::try_from(evaluate(context.clone(), cond)?)? {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: GcHashMap<IStr, LazyBinding> = GcHashMap::with_capacity(members.len());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				struct ObjMemberBinding {275					context_creator: ContextCreator,276					value: LocExpr,277					name: IStr,278				}279				impl Bindable for ObjMemberBinding {280					fn bind(281						&self,282						this: Option<ObjValue>,283						super_obj: Option<ObjValue>,284					) -> Result<LazyVal> {285						Ok(LazyVal::new_resolved(evaluate_named(286							self.context_creator.create(this, super_obj)?,287							&self.value,288							self.name.clone(),289						)?))290					}291				}292				builder293					.member(name.clone())294					.with_add(*plus)295					.with_visibility(*visibility)296					.with_location(value.1.clone())297					.bindable(TraceBox(Box::new(ObjMemberBinding {298						context_creator: context_creator.clone(),299						value: value.clone(),300						name,301					})));302			}303			Member::Field(FieldMember {304				name,305				params: Some(params),306				value,307				..308			}) => {309				let name = evaluate_field_name(context.clone(), name)?;310				if name.is_none() {311					continue;312				}313				let name = name.unwrap();314				#[derive(Trace)]315				struct ObjMemberBinding {316					context_creator: ContextCreator,317					value: LocExpr,318					params: ParamsDesc,319					name: IStr,320				}321				impl Bindable for ObjMemberBinding {322					fn bind(323						&self,324						this: Option<ObjValue>,325						super_obj: Option<ObjValue>,326					) -> Result<LazyVal> {327						Ok(LazyVal::new_resolved(evaluate_method(328							self.context_creator.create(this, super_obj)?,329							self.name.clone(),330							self.params.clone(),331							self.value.clone(),332						)))333					}334				}335				builder336					.member(name.clone())337					.hide()338					.with_location(value.1.clone())339					.bindable(TraceBox(Box::new(ObjMemberBinding {340						context_creator: context_creator.clone(),341						value: value.clone(),342						params: params.clone(),343						name,344					})));345			}346			Member::BindStmt(_) => {}347			Member::AssertStmt(stmt) => {348				#[derive(Trace)]349				struct ObjectAssert {350					context_creator: ContextCreator,351					assert: AssertStmt,352				}353				impl ObjectAssertion for ObjectAssert {354					fn run(355						&self,356						this: Option<ObjValue>,357						super_obj: Option<ObjValue>,358					) -> Result<()> {359						let ctx = self.context_creator.create(this, super_obj)?;360						evaluate_assert(ctx, &self.assert)361					}362				}363				builder.assert(TraceBox(Box::new(ObjectAssert {364					context_creator: context_creator.clone(),365					assert: stmt.clone(),366				})));367			}368		}369	}370	let this = builder.build();371	future_this.fill(this.clone());372	Ok(this)373}374375pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {376	Ok(match object {377		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,378		ObjBody::ObjComp(obj) => {379			let future_this = FutureWrapper::new();380			let mut builder = ObjValueBuilder::new();381			evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {382				let new_bindings = FutureWrapper::new();383				let context_creator = ContextCreator(context.clone(), new_bindings.clone());384				let mut bindings: GcHashMap<IStr, LazyBinding> =385					GcHashMap::with_capacity(obj.pre_locals.len() + obj.post_locals.len());386				for (n, b) in obj387					.pre_locals388					.iter()389					.chain(obj.post_locals.iter())390					.map(|b| evaluate_binding(b, context_creator.clone()))391				{392					bindings.insert(n, b);393				}394				new_bindings.fill(bindings.clone());395				let ctx = ctx.extend_unbound(bindings, None, None, None)?;396				let key = evaluate(ctx.clone(), &obj.key)?;397398				match key {399					Val::Null => {}400					Val::Str(n) => {401						#[derive(Trace)]402						struct ObjCompBinding {403							context: Context,404							value: LocExpr,405						}406						impl Bindable for ObjCompBinding {407							fn bind(408								&self,409								this: Option<ObjValue>,410								_super_obj: Option<ObjValue>,411							) -> Result<LazyVal> {412								Ok(LazyVal::new_resolved(evaluate(413									self.context414										.clone()415										.extend(GcHashMap::new(), None, this, None),416									&self.value,417								)?))418							}419						}420						builder421							.member(n)422							.with_location(obj.value.1.clone())423							.with_add(obj.plus)424							.bindable(TraceBox(Box::new(ObjCompBinding {425								context: ctx,426								value: obj.value.clone(),427							})));428					}429					v => throw!(FieldMustBeStringGot(v.value_type())),430				}431432				Ok(())433			})?;434435			let this = builder.build();436			future_this.fill(this.clone());437			this438		}439	})440}441442pub fn evaluate_apply(443	context: Context,444	value: &LocExpr,445	args: &ArgsDesc,446	loc: CallLocation,447	tailstrict: bool,448) -> Result<Val> {449	let value = evaluate(context.clone(), value)?;450	Ok(match value {451		Val::Func(f) => {452			let body = || f.evaluate(context, loc, args, tailstrict);453			if tailstrict {454				body()?455			} else {456				push_frame(loc, || format!("function <{}> call", f.name()), body)?457			}458		}459		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),460	})461}462463pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {464	let value = &assertion.0;465	let msg = &assertion.1;466	let assertion_result = push_frame(467		CallLocation::new(&value.1),468		|| "assertion condition".to_owned(),469		|| bool::try_from(evaluate(context.clone(), value)?),470	)?;471	if !assertion_result {472		push_frame(473			CallLocation::new(&value.1),474			|| "assertion failure".to_owned(),475			|| {476				if let Some(msg) = msg {477					throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));478				} else {479					throw!(AssertionFailed(Val::Null.to_string()?));480				}481			},482		)?483	}484	Ok(())485}486487pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {488	use Expr::*;489	let LocExpr(expr, _loc) = lexpr;490	Ok(match &**expr {491		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),492		_ => evaluate(context, lexpr)?,493	})494}495496pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {497	use Expr::*;498	let LocExpr(expr, loc) = expr;499	// let bp = with_state(|s| s.0.stop_at.borrow().clone());500	Ok(match &**expr {501		Literal(LiteralType::This) => {502			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)503		}504		Literal(LiteralType::Super) => Val::Obj(505			context506				.super_obj()507				.clone()508				.ok_or(NoSuperFound)?509				.with_this(context.this().clone().unwrap()),510		),511		Literal(LiteralType::Dollar) => {512			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)513		}514		Literal(LiteralType::True) => Val::Bool(true),515		Literal(LiteralType::False) => Val::Bool(false),516		Literal(LiteralType::Null) => Val::Null,517		Parened(e) => evaluate(context, e)?,518		Str(v) => Val::Str(v.clone()),519		Num(v) => Val::new_checked_num(*v)?,520		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,521		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,522		Var(name) => push_frame(523			CallLocation::new(loc),524			|| format!("variable <{}> access", name),525			|| context.binding(name.clone())?.evaluate(),526		)?,527		Index(value, index) => {528			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {529				(Val::Obj(v), Val::Str(s)) => {530					let sn = s.clone();531					push_frame(532						CallLocation::new(loc),533						|| format!("field <{}> access", sn),534						|| {535							if let Some(v) = v.get(s.clone())? {536								Ok(v)537							} else {538								throw!(NoSuchField(s))539							}540						},541					)?542				}543				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(544					ValType::Obj,545					ValType::Str,546					n.value_type(),547				)),548549				(Val::Arr(v), Val::Num(n)) => {550					if n.fract() > f64::EPSILON {551						throw!(FractionalIndex)552					}553					v.get(n as usize)?554						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?555				}556				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),557				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(558					ValType::Arr,559					ValType::Num,560					n.value_type(),561				)),562563				(Val::Str(s), Val::Num(n)) => Val::Str(564					s.chars()565						.skip(n as usize)566						.take(1)567						.collect::<String>()568						.into(),569				),570				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(571					ValType::Str,572					ValType::Num,573					n.value_type(),574				)),575576				(v, _) => throw!(CantIndexInto(v.value_type())),577			}578		}579		LocalExpr(bindings, returned) => {580			let mut new_bindings: GcHashMap<IStr, LazyVal> =581				GcHashMap::with_capacity(bindings.len());582			let future_context = Context::new_future();583			for b in bindings {584				new_bindings.insert(585					b.name.clone(),586					evaluate_binding_in_future(b, future_context.clone()),587				);588			}589			let context = context590				.extend_bound(new_bindings)591				.into_future(future_context);592			evaluate(context, &returned.clone())?593		}594		Arr(items) => {595			let mut out = Vec::with_capacity(items.len());596			for item in items {597				// TODO: Implement ArrValue::Lazy with same context for every element?598				#[derive(Trace)]599				struct ArrayElement {600					context: Context,601					item: LocExpr,602				}603				impl LazyValValue for ArrayElement {604					fn get(self: Box<Self>) -> Result<Val> {605						evaluate(self.context, &self.item)606					}607				}608				out.push(LazyVal::new(TraceBox(Box::new(ArrayElement {609					context: context.clone(),610					item: item.clone(),611				}))));612			}613			Val::Arr(out.into())614		}615		ArrComp(expr, comp_specs) => {616			let mut out = Vec::new();617			evaluate_comp(context, comp_specs, &mut |ctx| {618				out.push(evaluate(ctx, expr)?);619				Ok(())620			})?;621			Val::Arr(ArrValue::Eager(Cc::new(out)))622		}623		Obj(body) => Val::Obj(evaluate_object(context, body)?),624		ObjExtend(s, t) => evaluate_add_op(625			&evaluate(context.clone(), s)?,626			&Val::Obj(evaluate_object(context, t)?),627		)?,628		Apply(value, args, tailstrict) => {629			evaluate_apply(context, value, args, CallLocation::new(loc), *tailstrict)?630		}631		Function(params, body) => {632			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())633		}634		Intrinsic(name) => Val::Func(FuncVal::StaticBuiltin(635			BUILTINS636				.with(|b| b.get(name).copied())637				.ok_or_else(|| IntrinsicNotFound(name.clone()))?,638		)),639		AssertExpr(assert, returned) => {640			evaluate_assert(context.clone(), assert)?;641			evaluate(context, returned)?642		}643		ErrorStmt(e) => push_frame(644			CallLocation::new(loc),645			|| "error statement".to_owned(),646			|| throw!(RuntimeError(IStr::try_from(evaluate(context, e)?)?,)),647		)?,648		IfElse {649			cond,650			cond_then,651			cond_else,652		} => {653			if push_frame(654				CallLocation::new(loc),655				|| "if condition".to_owned(),656				|| bool::try_from(evaluate(context.clone(), &cond.0)?),657			)? {658				evaluate(context, cond_then)?659			} else {660				match cond_else {661					Some(v) => evaluate(context, v)?,662					None => Val::Null,663				}664			}665		}666		Slice(value, desc) => {667			let indexable = evaluate(context.clone(), value)?;668669			fn parse_num(670				context: &Context,671				expr: Option<&LocExpr>,672				desc: &'static str,673			) -> Result<Option<usize>> {674				Ok(match expr {675					Some(s) => evaluate(context.clone(), s)?676						.try_cast_nullable_num(desc)?677						.map(|v| v as usize),678					None => None,679				})680			}681682			let start = parse_num(&context, desc.start.as_ref(), "start")?;683			let end = parse_num(&context, desc.end.as_ref(), "end")?;684			let step = parse_num(&context, desc.step.as_ref(), "step")?;685686			std_slice(indexable.into_indexable()?, start, end, step)?687		}688		Import(path) => {689			let tmp = loc.clone().0;690			let mut import_location = tmp.to_path_buf();691			import_location.pop();692			push_frame(693				CallLocation::new(loc),694				|| format!("import {:?}", path),695				|| with_state(|s| s.import_file(&import_location, path)),696			)?697		}698		ImportStr(path) => {699			let tmp = loc.clone().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}