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

1use std::rc::Rc;23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,7	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,8};9use jrsonnet_types::ValType;1011use self::destructure::destruct;12use crate::{13	arr::ArrValue,14	bail,15	destructure::evaluate_dest,16	error::{suggest_object_fields, ErrorKind::*},17	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},18	function::{CallLocation, FuncDesc, FuncVal},19	typed::Typed,20	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk, ThunkValue},21	Context, Error, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,22	ResultExt, State, Unbound, Val,23};24pub mod destructure;25pub mod operator;2627pub fn evaluate_trivial(expr: &LocExpr) -> Option<Val> {28	fn is_trivial(expr: &LocExpr) -> bool {29		match &*expr.0 {30			Expr::Str(_)31			| Expr::Num(_)32			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,33			Expr::Arr(a) => a.iter().all(is_trivial),34			Expr::Parened(e) => is_trivial(e),35			_ => false,36		}37	}38	Some(match &*expr.0 {39		Expr::Str(s) => Val::string(s.clone()),40		Expr::Num(n) => {41			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))42		}43		Expr::Literal(LiteralType::False) => Val::Bool(false),44		Expr::Literal(LiteralType::True) => Val::Bool(true),45		Expr::Literal(LiteralType::Null) => Val::Null,46		Expr::Arr(n) => {47			if n.iter().any(|e| !is_trivial(e)) {48				return None;49			}50			Val::Arr(ArrValue::eager(51				n.iter()52					.map(evaluate_trivial)53					.map(|e| e.expect("checked trivial"))54					.collect(),55			))56		}57		Expr::Parened(e) => evaluate_trivial(e)?,58		_ => return None,59	})60}6162pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {63	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {64		name,65		ctx,66		params,67		body,68	})))69}7071pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {72	Ok(match field_name {73		FieldName::Fixed(n) => Some(n.clone()),74		FieldName::Dyn(expr) => State::push(75			CallLocation::new(&expr.1),76			|| "evaluating field name".to_string(),77			|| {78				let value = evaluate(ctx, expr)?;79				if matches!(value, Val::Null) {80					Ok(None)81				} else {82					Ok(Some(IStr::from_untyped(value)?))83				}84			},85		)?,86	})87}8889pub fn evaluate_comp(90	ctx: Context,91	specs: &[CompSpec],92	callback: &mut impl FnMut(Context) -> Result<()>,93) -> Result<()> {94	match specs.first() {95		None => callback(ctx)?,96		Some(CompSpec::IfSpec(IfSpecData(cond))) => {97			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {98				evaluate_comp(ctx, &specs[1..], callback)?;99			}100		}101		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {102			Val::Arr(list) => {103				for item in list.iter_lazy() {104					let fctx = Pending::new();105					let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());106					destruct(var, item, fctx.clone(), &mut new_bindings)?;107					let ctx = ctx108						.clone()109						.extend(new_bindings, None, None, None)110						.into_future(fctx);111112					evaluate_comp(ctx, &specs[1..], callback)?;113				}114			}115			#[cfg(feature = "exp-object-iteration")]116			Val::Obj(obj) => {117				for field in obj.fields(118					// TODO: Should there be ability to preserve iteration order?119					#[cfg(feature = "exp-preserve-order")]120					false,121				) {122					#[derive(Trace)]123					struct ObjectFieldThunk {124						obj: ObjValue,125						field: IStr,126					}127					impl ThunkValue for ObjectFieldThunk {128						type Output = Val;129130						fn get(self: Box<Self>) -> Result<Self::Output> {131							self.obj.get(self.field).transpose().expect(132								"field exists, as field name was obtained from object.fields()",133							)134						}135					}136137					let fctx = Pending::new();138					let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());139					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![140						Thunk::evaluated(Val::string(field.clone())),141						Thunk::new(ObjectFieldThunk {142							field: field.clone(),143							obj: obj.clone(),144						}),145					])));146					destruct(var, value, fctx.clone(), &mut new_bindings)?;147					let ctx = ctx148						.clone()149						.extend(new_bindings, None, None, None)150						.into_future(fctx);151152					evaluate_comp(ctx, &specs[1..], callback)?;153				}154			}155			_ => bail!(InComprehensionCanOnlyIterateOverArray),156		},157	}158	Ok(())159}160161trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}162impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}163164fn evaluate_object_locals(165	fctx: Pending<Context>,166	locals: Rc<Vec<BindSpec>>,167) -> impl CloneableUnbound<Context> {168	#[derive(Trace, Clone)]169	struct UnboundLocals {170		fctx: Pending<Context>,171		locals: Rc<Vec<BindSpec>>,172	}173	impl Unbound for UnboundLocals {174		type Bound = Context;175176		fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Context> {177			let fctx = Context::new_future();178			let mut new_bindings =179				GcHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());180			for b in self.locals.iter() {181				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;182			}183184			let ctx = self.fctx.unwrap();185			let new_dollar = ctx.dollar().cloned().or_else(|| this.clone());186187			let ctx = ctx188				.extend(new_bindings, new_dollar, sup, this)189				.into_future(fctx);190191			Ok(ctx)192		}193	}194195	UnboundLocals { fctx, locals }196}197198pub fn evaluate_field_member<B: Unbound<Bound = Context> + Clone>(199	builder: &mut ObjValueBuilder,200	ctx: Context,201	uctx: B,202	field: &FieldMember,203) -> Result<()> {204	let name = evaluate_field_name(ctx, &field.name)?;205	let Some(name) = name else {206		return Ok(());207	};208209	match field {210		FieldMember {211			plus,212			params: None,213			visibility,214			value,215			..216		} => {217			#[derive(Trace)]218			struct UnboundValue<B: Trace> {219				uctx: B,220				value: LocExpr,221				name: IStr,222			}223			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {224				type Bound = Val;225				fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {226					evaluate_named(self.uctx.bind(sup, this)?, &self.value, self.name.clone())227				}228			}229230			builder231				.field(name.clone())232				.with_add(*plus)233				.with_visibility(*visibility)234				.with_location(value.1.clone())235				.bindable(UnboundValue {236					uctx,237					value: value.clone(),238					name,239				})?;240		}241		FieldMember {242			params: Some(params),243			visibility,244			value,245			..246		} => {247			#[derive(Trace)]248			struct UnboundMethod<B: Trace> {249				uctx: B,250				value: LocExpr,251				params: ParamsDesc,252				name: IStr,253			}254			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {255				type Bound = Val;256				fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {257					Ok(evaluate_method(258						self.uctx.bind(sup, this)?,259						self.name.clone(),260						self.params.clone(),261						self.value.clone(),262					))263				}264			}265266			builder267				.field(name.clone())268				.with_visibility(*visibility)269				.with_location(value.1.clone())270				.bindable(UnboundMethod {271					uctx,272					value: value.clone(),273					params: params.clone(),274					name,275				})?;276		}277	}278	Ok(())279}280281#[allow(clippy::too_many_lines)]282pub fn evaluate_member_list_object(ctx: Context, members: &[Member]) -> Result<ObjValue> {283	let mut builder = ObjValueBuilder::new();284	let locals = Rc::new(285		members286			.iter()287			.filter_map(|m| match m {288				Member::BindStmt(bind) => Some(bind.clone()),289				_ => None,290			})291			.collect::<Vec<_>>(),292	);293294	let fctx = Context::new_future();295296	// We have single context for all fields, so we can cache binds297	let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));298299	for member in members {300		match member {301			Member::Field(field) => {302				evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;303			}304			Member::AssertStmt(stmt) => {305				#[derive(Trace)]306				struct ObjectAssert<B: Trace> {307					uctx: B,308					assert: AssertStmt,309				}310				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {311					fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {312						let ctx = self.uctx.bind(sup, this)?;313						evaluate_assert(ctx, &self.assert)314					}315				}316				builder.assert(ObjectAssert {317					uctx: uctx.clone(),318					assert: stmt.clone(),319				});320			}321			Member::BindStmt(_) => {322				// Already handled323			}324		}325	}326	let this = builder.build();327	fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));328	Ok(this)329}330331pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {332	Ok(match object {333		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,334		ObjBody::ObjComp(obj) => {335			let mut builder = ObjValueBuilder::new();336			let locals = Rc::new(337				obj.pre_locals338					.iter()339					.chain(obj.post_locals.iter())340					.cloned()341					.collect::<Vec<_>>(),342			);343			let mut ctxs = vec![];344			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {345				let fctx = Context::new_future();346				ctxs.push((ctx.clone(), fctx.clone()));347				let uctx = evaluate_object_locals(fctx, locals.clone());348349				evaluate_field_member(&mut builder, ctx, uctx, &obj.field)350			})?;351352			let this = builder.build();353			for (ctx, fctx) in ctxs {354				let _ctx = ctx355					.extend(GcHashMap::new(), None, None, Some(this.clone()))356					.into_future(fctx);357			}358			this359		}360	})361}362363pub fn evaluate_apply(364	ctx: Context,365	value: &LocExpr,366	args: &ArgsDesc,367	loc: CallLocation<'_>,368	tailstrict: bool,369) -> Result<Val> {370	let value = evaluate(ctx.clone(), value)?;371	Ok(match value {372		Val::Func(f) => {373			let body = || f.evaluate(ctx, loc, args, tailstrict);374			if tailstrict {375				body()?376			} else {377				State::push(loc, || format!("function <{}> call", f.name()), body)?378			}379		}380		v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),381	})382}383384pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {385	let value = &assertion.0;386	let msg = &assertion.1;387	let assertion_result = State::push(388		CallLocation::new(&value.1),389		|| "assertion condition".to_owned(),390		|| bool::from_untyped(evaluate(ctx.clone(), value)?),391	)?;392	if !assertion_result {393		State::push(394			CallLocation::new(&value.1),395			|| "assertion failure".to_owned(),396			|| {397				if let Some(msg) = msg {398					bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));399				}400				bail!(AssertionFailed(Val::Null.to_string()?));401			},402		)?;403	}404	Ok(())405}406407pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {408	use Expr::*;409	let LocExpr(raw_expr, _loc) = expr;410	Ok(match &**raw_expr {411		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),412		_ => evaluate(ctx, expr)?,413	})414}415416#[allow(clippy::too_many_lines)]417pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {418	use Expr::*;419420	if let Some(trivial) = evaluate_trivial(expr) {421		return Ok(trivial);422	}423	let LocExpr(expr, loc) = expr;424	Ok(match &**expr {425		Literal(LiteralType::This) => {426			Val::Obj(ctx.this().ok_or(CantUseSelfOutsideOfObject)?.clone())427		}428		Literal(LiteralType::Super) => Val::Obj(429			ctx.super_obj().ok_or(NoSuperFound)?.with_this(430				ctx.this()431					.expect("if super exists - then this should too")432					.clone(),433			),434		),435		Literal(LiteralType::Dollar) => {436			Val::Obj(ctx.dollar().ok_or(NoTopLevelObjectFound)?.clone())437		}438		Literal(LiteralType::True) => Val::Bool(true),439		Literal(LiteralType::False) => Val::Bool(false),440		Literal(LiteralType::Null) => Val::Null,441		Parened(e) => evaluate(ctx, e)?,442		Str(v) => Val::string(v.clone()),443		Num(v) => Val::try_num(*v)?,444		// I have tried to remove special behavior from super by implementing standalone-super445		// expresion, but looks like this case still needs special treatment.446		//447		// Note that other jsonnet implementations will fail on `if value in (super)` expression,448		// because the standalone super literal is not supported, that is because in other449		// implementations `in super` treated differently from in `smth_else`.450		BinaryOp(field, BinaryOpType::In, e)451			if matches!(&*e.0, Expr::Literal(LiteralType::Super)) =>452		{453			let Some(super_obj) = ctx.super_obj() else {454				return Ok(Val::Bool(false));455			};456			let field = evaluate(ctx.clone(), field)?;457			Val::Bool(super_obj.has_field_ex(field.to_string()?, true))458		}459		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,460		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,461		Var(name) => State::push(462			CallLocation::new(loc),463			|| format!("variable <{name}> access"),464			|| ctx.binding(name.clone())?.evaluate(),465		)?,466		Index { indexable, parts } => {467			let mut parts = parts.iter();468			let mut indexable = match &indexable {469				// Cheaper to execute than creating object with overriden `this`470				LocExpr(v, _) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {471					let part = parts.next().expect("at least part should exist");472					let Some(super_obj) = ctx.super_obj() else {473						#[cfg(feature = "exp-null-coaelse")]474						if part.null_coaelse {475							return Ok(Val::Null);476						}477						bail!(NoSuperFound)478					};479					let name = evaluate(ctx.clone(), &part.value)?;480481					let Val::Str(name) = name else {482						bail!(ValueIndexMustBeTypeGot(483							ValType::Obj,484							ValType::Str,485							name.value_type(),486						))487					};488489					let this = ctx490						.this()491						.expect("no this found, while super present, should not happen");492					let name = name.into_flat();493					match super_obj494						.get_for(name.clone(), this.clone())495						.with_description_src(&part.value, || format!("field <{name}> access"))?496					{497						Some(v) => v,498						#[cfg(feature = "exp-null-coaelse")]499						None if part.null_coaelse => return Ok(Val::Null),500						None => {501							let suggestions = suggest_object_fields(super_obj, name.clone());502503							bail!(NoSuchField(name, suggestions))504						}505					}506				}507				e => evaluate(ctx.clone(), e)?,508			};509510			for part in parts {511				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {512					(Val::Obj(v), Val::Str(key)) => match v513						.get(key.clone().into_flat())514						.with_description_src(&part.value, || format!("field <{key}> access"))?515					{516						Some(v) => v,517						#[cfg(feature = "exp-null-coaelse")]518						None if part.null_coaelse => return Ok(Val::Null),519						None => {520							let suggestions = suggest_object_fields(&v, key.clone().into_flat());521522							return Err(Error::from(NoSuchField(523								key.clone().into_flat(),524								suggestions,525							)))526							.with_description_src(&part.value, || format!("field <{key}> access"));527						}528					},529					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(530						ValType::Obj,531						ValType::Str,532						n.value_type(),533					)),534					(Val::Arr(v), Val::Num(n)) => {535						let n = n.get();536						if n.fract() > f64::EPSILON {537							bail!(FractionalIndex)538						}539						if n < 0.0 {540							bail!(ArrayBoundsError(n as isize, v.len()));541						}542						v.get(n as usize)?543							.ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?544					}545					(Val::Arr(_), Val::Str(n)) => {546						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))547					}548					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(549						ValType::Arr,550						ValType::Num,551						n.value_type(),552					)),553554					(Val::Str(s), Val::Num(n)) => Val::Str({555						let v: IStr = s556							.clone()557							.into_flat()558							.chars()559							.skip(n.get() as usize)560							.take(1)561							.collect::<String>()562							.into();563						if v.is_empty() {564							let size = s.into_flat().chars().count();565							bail!(StringBoundsError(n.get() as usize, size))566						}567						StrValue::Flat(v)568					}),569					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(570						ValType::Str,571						ValType::Num,572						n.value_type(),573					)),574					#[cfg(feature = "exp-null-coaelse")]575					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),576					(v, _) => bail!(CantIndexInto(v.value_type())),577				};578			}579			indexable580		}581		LocalExpr(bindings, returned) => {582			let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =583				GcHashMap::with_capacity(bindings.iter().map(BindSpec::capacity_hint).sum());584			let fctx = Context::new_future();585			for b in bindings {586				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;587			}588			let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);589			evaluate(ctx, &returned.clone())?590		}591		Arr(items) => {592			if items.is_empty() {593				Val::Arr(ArrValue::empty())594			} else if items.len() == 1 {595				#[derive(Trace)]596				struct ArrayElement {597					ctx: Context,598					item: LocExpr,599				}600				impl ThunkValue for ArrayElement {601					type Output = Val;602					fn get(self: Box<Self>) -> Result<Val> {603						evaluate(self.ctx, &self.item)604					}605				}606				Val::Arr(ArrValue::lazy(vec![Thunk::new(ArrayElement {607					ctx,608					item: items[0].clone(),609				})]))610			} else {611				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))612			}613		}614		ArrComp(expr, comp_specs) => {615			let mut out = Vec::new();616			evaluate_comp(ctx, comp_specs, &mut |ctx| {617				#[derive(Trace)]618				struct EvaluateThunk {619					ctx: Context,620					expr: LocExpr,621				}622				impl ThunkValue for EvaluateThunk {623					type Output = Val;624					fn get(self: Box<Self>) -> Result<Val> {625						evaluate(self.ctx, &self.expr)626					}627				}628				out.push(Thunk::new(EvaluateThunk {629					ctx,630					expr: expr.clone(),631				}));632				Ok(())633			})?;634			Val::Arr(ArrValue::lazy(out))635		}636		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),637		ObjExtend(a, b) => evaluate_add_op(638			&evaluate(ctx.clone(), a)?,639			&Val::Obj(evaluate_object(ctx, b)?),640		)?,641		Apply(value, args, tailstrict) => {642			evaluate_apply(ctx, value, args, CallLocation::new(loc), *tailstrict)?643		}644		Function(params, body) => {645			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())646		}647		AssertExpr(assert, returned) => {648			evaluate_assert(ctx.clone(), assert)?;649			evaluate(ctx, returned)?650		}651		ErrorStmt(e) => State::push(652			CallLocation::new(loc),653			|| "error statement".to_owned(),654			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),655		)?,656		IfElse {657			cond,658			cond_then,659			cond_else,660		} => {661			if State::push(662				CallLocation::new(loc),663				|| "if condition".to_owned(),664				|| bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),665			)? {666				evaluate(ctx, cond_then)?667			} else {668				match cond_else {669					Some(v) => evaluate(ctx, v)?,670					None => Val::Null,671				}672			}673		}674		Slice(value, desc) => {675			fn parse_idx<T: Typed>(676				loc: CallLocation<'_>,677				ctx: &Context,678				expr: Option<&LocExpr>,679				desc: &'static str,680			) -> Result<Option<T>> {681				if let Some(value) = expr {682					Ok(Some(State::push(683						loc,684						|| format!("slice {desc}"),685						|| T::from_untyped(evaluate(ctx.clone(), value)?),686					)?))687				} else {688					Ok(None)689				}690			}691692			let indexable = evaluate(ctx.clone(), value)?;693			let loc = CallLocation::new(loc);694695			let start = parse_idx(loc, &ctx, desc.start.as_ref(), "start")?;696			let end = parse_idx(loc, &ctx, desc.end.as_ref(), "end")?;697			let step = parse_idx(loc, &ctx, desc.step.as_ref(), "step")?;698699			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?700		}701		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {702			let Expr::Str(path) = &*path.0 else {703				bail!("computed imports are not supported")704			};705			let tmp = loc.clone().0;706			let s = ctx.state();707			let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;708			match i {709				Import(_) => State::push(710					CallLocation::new(loc),711					|| format!("import {:?}", path.clone()),712					|| s.import_resolved(resolved_path),713				)?,714				ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),715				ImportBin(_) => Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?)),716				_ => unreachable!(),717			}718		}719	})720}