git.delta.rocks / jrsonnet / refs/commits / 7b38a7f3268f

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.expr() {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.expr() {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.span()),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.span())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.span())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.span()),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.span()),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	Ok(match expr.expr() {410		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),411		_ => evaluate(ctx, expr)?,412	})413}414415#[allow(clippy::too_many_lines)]416pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {417	use Expr::*;418419	if let Some(trivial) = evaluate_trivial(expr) {420		return Ok(trivial);421	}422	let loc = expr.span();423	Ok(match expr.expr() {424		Literal(LiteralType::This) => {425			Val::Obj(ctx.this().ok_or(CantUseSelfOutsideOfObject)?.clone())426		}427		Literal(LiteralType::Super) => Val::Obj(428			ctx.super_obj().ok_or(NoSuperFound)?.with_this(429				ctx.this()430					.expect("if super exists - then this should too")431					.clone(),432			),433		),434		Literal(LiteralType::Dollar) => {435			Val::Obj(ctx.dollar().ok_or(NoTopLevelObjectFound)?.clone())436		}437		Literal(LiteralType::True) => Val::Bool(true),438		Literal(LiteralType::False) => Val::Bool(false),439		Literal(LiteralType::Null) => Val::Null,440		Parened(e) => evaluate(ctx, e)?,441		Str(v) => Val::string(v.clone()),442		Num(v) => Val::try_num(*v)?,443		// I have tried to remove special behavior from super by implementing standalone-super444		// expresion, but looks like this case still needs special treatment.445		//446		// Note that other jsonnet implementations will fail on `if value in (super)` expression,447		// because the standalone super literal is not supported, that is because in other448		// implementations `in super` treated differently from in `smth_else`.449		BinaryOp(field, BinaryOpType::In, e)450			if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>451		{452			let Some(super_obj) = ctx.super_obj() else {453				return Ok(Val::Bool(false));454			};455			let field = evaluate(ctx.clone(), field)?;456			Val::Bool(super_obj.has_field_ex(field.to_string()?, true))457		}458		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,459		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,460		Var(name) => State::push(461			CallLocation::new(&loc),462			|| format!("variable <{name}> access"),463			|| ctx.binding(name.clone())?.evaluate(),464		)?,465		Index { indexable, parts } => {466			let mut parts = parts.iter();467			let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {468				let part = parts.next().expect("at least part should exist");469				let Some(super_obj) = ctx.super_obj() else {470					#[cfg(feature = "exp-null-coaelse")]471					if part.null_coaelse {472						return Ok(Val::Null);473					}474					bail!(NoSuperFound)475				};476				let name = evaluate(ctx.clone(), &part.value)?;477478				let Val::Str(name) = name else {479					bail!(ValueIndexMustBeTypeGot(480						ValType::Obj,481						ValType::Str,482						name.value_type(),483					))484				};485486				let this = ctx487					.this()488					.expect("no this found, while super present, should not happen");489				let name = name.into_flat();490				match super_obj491					.get_for(name.clone(), this.clone())492					.with_description_src(&part.value, || format!("field <{name}> access"))?493				{494					Some(v) => v,495					#[cfg(feature = "exp-null-coaelse")]496					None if part.null_coaelse => return Ok(Val::Null),497					None => {498						let suggestions = suggest_object_fields(super_obj, name.clone());499500						bail!(NoSuchField(name, suggestions))501					}502				}503			} else {504				evaluate(ctx.clone(), indexable)?505			};506507			for part in parts {508				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {509					(Val::Obj(v), Val::Str(key)) => match v510						.get(key.clone().into_flat())511						.with_description_src(&part.value, || format!("field <{key}> access"))?512					{513						Some(v) => v,514						#[cfg(feature = "exp-null-coaelse")]515						None if part.null_coaelse => return Ok(Val::Null),516						None => {517							let suggestions = suggest_object_fields(&v, key.clone().into_flat());518519							return Err(Error::from(NoSuchField(520								key.clone().into_flat(),521								suggestions,522							)))523							.with_description_src(&part.value, || format!("field <{key}> access"));524						}525					},526					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(527						ValType::Obj,528						ValType::Str,529						n.value_type(),530					)),531					(Val::Arr(v), Val::Num(n)) => {532						let n = n.get();533						if n.fract() > f64::EPSILON {534							bail!(FractionalIndex)535						}536						if n < 0.0 {537							bail!(ArrayBoundsError(n as isize, v.len()));538						}539						v.get(n as usize)?540							.ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?541					}542					(Val::Arr(_), Val::Str(n)) => {543						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))544					}545					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(546						ValType::Arr,547						ValType::Num,548						n.value_type(),549					)),550551					(Val::Str(s), Val::Num(n)) => Val::Str({552						let v: IStr = s553							.clone()554							.into_flat()555							.chars()556							.skip(n.get() as usize)557							.take(1)558							.collect::<String>()559							.into();560						if v.is_empty() {561							let size = s.into_flat().chars().count();562							bail!(StringBoundsError(n.get() as usize, size))563						}564						StrValue::Flat(v)565					}),566					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(567						ValType::Str,568						ValType::Num,569						n.value_type(),570					)),571					#[cfg(feature = "exp-null-coaelse")]572					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),573					(v, _) => bail!(CantIndexInto(v.value_type())),574				};575			}576			indexable577		}578		LocalExpr(bindings, returned) => {579			let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =580				GcHashMap::with_capacity(bindings.iter().map(BindSpec::capacity_hint).sum());581			let fctx = Context::new_future();582			for b in bindings {583				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;584			}585			let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);586			evaluate(ctx, &returned.clone())?587		}588		Arr(items) => {589			if items.is_empty() {590				Val::Arr(ArrValue::empty())591			} else if items.len() == 1 {592				#[derive(Trace)]593				struct ArrayElement {594					ctx: Context,595					item: LocExpr,596				}597				impl ThunkValue for ArrayElement {598					type Output = Val;599					fn get(self: Box<Self>) -> Result<Val> {600						evaluate(self.ctx, &self.item)601					}602				}603				Val::Arr(ArrValue::lazy(vec![Thunk::new(ArrayElement {604					ctx,605					item: items[0].clone(),606				})]))607			} else {608				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))609			}610		}611		ArrComp(expr, comp_specs) => {612			let mut out = Vec::new();613			evaluate_comp(ctx, comp_specs, &mut |ctx| {614				#[derive(Trace)]615				struct EvaluateThunk {616					ctx: Context,617					expr: LocExpr,618				}619				impl ThunkValue for EvaluateThunk {620					type Output = Val;621					fn get(self: Box<Self>) -> Result<Val> {622						evaluate(self.ctx, &self.expr)623					}624				}625				out.push(Thunk::new(EvaluateThunk {626					ctx,627					expr: expr.clone(),628				}));629				Ok(())630			})?;631			Val::Arr(ArrValue::lazy(out))632		}633		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),634		ObjExtend(a, b) => evaluate_add_op(635			&evaluate(ctx.clone(), a)?,636			&Val::Obj(evaluate_object(ctx, b)?),637		)?,638		Apply(value, args, tailstrict) => {639			evaluate_apply(ctx, value, args, CallLocation::new(&loc), *tailstrict)?640		}641		Function(params, body) => {642			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())643		}644		AssertExpr(assert, returned) => {645			evaluate_assert(ctx.clone(), assert)?;646			evaluate(ctx, returned)?647		}648		ErrorStmt(e) => State::push(649			CallLocation::new(&loc),650			|| "error statement".to_owned(),651			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),652		)?,653		IfElse {654			cond,655			cond_then,656			cond_else,657		} => {658			if State::push(659				CallLocation::new(&loc),660				|| "if condition".to_owned(),661				|| bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),662			)? {663				evaluate(ctx, cond_then)?664			} else {665				match cond_else {666					Some(v) => evaluate(ctx, v)?,667					None => Val::Null,668				}669			}670		}671		Slice(value, desc) => {672			fn parse_idx<T: Typed>(673				loc: CallLocation<'_>,674				ctx: &Context,675				expr: Option<&LocExpr>,676				desc: &'static str,677			) -> Result<Option<T>> {678				if let Some(value) = expr {679					Ok(Some(State::push(680						loc,681						|| format!("slice {desc}"),682						|| T::from_untyped(evaluate(ctx.clone(), value)?),683					)?))684				} else {685					Ok(None)686				}687			}688689			let indexable = evaluate(ctx.clone(), value)?;690			let loc = CallLocation::new(&loc);691692			let start = parse_idx(loc, &ctx, desc.start.as_ref(), "start")?;693			let end = parse_idx(loc, &ctx, desc.end.as_ref(), "end")?;694			let step = parse_idx(loc, &ctx, desc.step.as_ref(), "step")?;695696			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?697		}698		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {699			let Expr::Str(path) = &path.expr() else {700				bail!("computed imports are not supported")701			};702			let tmp = loc.clone().0;703			let s = ctx.state();704			let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;705			match i {706				Import(_) => State::push(707					CallLocation::new(&loc),708					|| format!("import {:?}", path.clone()),709					|| s.import_resolved(resolved_path),710				)?,711				ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),712				ImportBin(_) => Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?)),713				_ => unreachable!(),714			}715		}716	})717}