git.delta.rocks / jrsonnet / refs/commits / 5f9657289c33

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;10use rustc_hash::FxHashMap;1112use self::destructure::destruct;13use crate::{14	arr::ArrValue,15	bail,16	destructure::evaluate_dest,17	error::{suggest_object_fields, ErrorKind::*},18	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},19	function::{CallLocation, FuncDesc, FuncVal},20	gc::WithCapacityExt as _,21	in_frame,22	typed::Typed,23	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},24	with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,25	ResultExt, SupThis, Unbound, Val,26};27pub mod destructure;28pub mod operator;2930// This is the amount of bytes that need to be left on the stack before increasing the size.31// It must be at least as large as the stack required by any code that does not call32// `ensure_sufficient_stack`.33const RED_ZONE: usize = 100 * 1024; // 100k3435// Only the first stack that is pushed, grows exponentially (2^n * STACK_PER_RECURSION) from then36// on. This flag has performance relevant characteristics. Don't set it too high.37const STACK_PER_RECURSION: usize = 1024 * 1024; // 1MB3839/// Grows the stack on demand to prevent stack overflow. Call this in strategic locations40/// to "break up" recursive calls. E.g. almost any call to `visit_expr` or equivalent can benefit41/// from this.42///43/// Should not be sprinkled around carelessly, as it causes a little bit of overhead.44#[inline]45pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {46	stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)47}4849pub fn evaluate_trivial(expr: &LocExpr) -> Option<Val> {50	fn is_trivial(expr: &LocExpr) -> bool {51		match expr.expr() {52			Expr::Str(_)53			| Expr::Num(_)54			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,55			Expr::Arr(a) => a.iter().all(is_trivial),56			Expr::Parened(e) => is_trivial(e),57			_ => false,58		}59	}60	Some(match expr.expr() {61		Expr::Str(s) => Val::string(s.clone()),62		Expr::Num(n) => {63			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))64		}65		Expr::Literal(LiteralType::False) => Val::Bool(false),66		Expr::Literal(LiteralType::True) => Val::Bool(true),67		Expr::Literal(LiteralType::Null) => Val::Null,68		Expr::Arr(n) => {69			if n.iter().any(|e| !is_trivial(e)) {70				return None;71			}72			Val::Arr(ArrValue::eager(73				n.iter()74					.map(evaluate_trivial)75					.map(|e| e.expect("checked trivial"))76					.collect(),77			))78		}79		Expr::Parened(e) => evaluate_trivial(e)?,80		_ => return None,81	})82}8384pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {85	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {86		name,87		ctx,88		params,89		body,90	})))91}9293pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {94	Ok(match field_name {95		FieldName::Fixed(n) => Some(n.clone()),96		FieldName::Dyn(expr) => in_frame(97			CallLocation::new(&expr.span()),98			|| "evaluating field name".to_string(),99			|| {100				let value = evaluate(ctx, expr)?;101				if matches!(value, Val::Null) {102					Ok(None)103				} else {104					Ok(Some(IStr::from_untyped(value)?))105				}106			},107		)?,108	})109}110111pub fn evaluate_comp(112	ctx: Context,113	specs: &[CompSpec],114	callback: &mut impl FnMut(Context) -> Result<()>,115) -> Result<()> {116	match specs.first() {117		None => callback(ctx)?,118		Some(CompSpec::IfSpec(IfSpecData(cond))) => {119			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {120				evaluate_comp(ctx, &specs[1..], callback)?;121			}122		}123		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {124			Val::Arr(list) => {125				for item in list.iter_lazy() {126					let fctx = Pending::new();127					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());128					destruct(var, item, fctx.clone(), &mut new_bindings)?;129					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);130131					evaluate_comp(ctx, &specs[1..], callback)?;132				}133			}134			#[cfg(feature = "exp-object-iteration")]135			Val::Obj(obj) => {136				for field in obj.fields(137					// TODO: Should there be ability to preserve iteration order?138					#[cfg(feature = "exp-preserve-order")]139					false,140				) {141					let fctx = Pending::new();142					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());143					let obj = obj.clone();144					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![145						Thunk::evaluated(Val::string(field.clone())),146						Thunk!(move || obj.get(field).transpose().expect(147							"field exists, as field name was obtained from object.fields()",148						)),149					])));150					destruct(var, value, fctx.clone(), &mut new_bindings)?;151					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);152153					evaluate_comp(ctx, &specs[1..], callback)?;154				}155			}156			_ => bail!(InComprehensionCanOnlyIterateOverArray),157		},158	}159	Ok(())160}161162trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}163impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}164165fn evaluate_object_locals(166	fctx: Context,167	locals: Rc<Vec<BindSpec>>,168) -> impl CloneableUnbound<Context> {169	#[derive(Trace, Clone)]170	struct UnboundLocals {171		fctx: Context,172		locals: Rc<Vec<BindSpec>>,173	}174	impl Unbound for UnboundLocals {175		type Bound = Context;176177		fn bind(&self, sup_this: SupThis) -> Result<Context> {178			let fctx = Context::new_future();179			let mut new_bindings =180				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());181			for b in self.locals.iter() {182				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;183			}184185			let ctx = self.fctx.clone();186187			let ctx = ctx188				.extend_bindings_sup_this(new_bindings, 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_this: SupThis) -> 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_this: SupThis) -> 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	// We have single context for all fields, so we can cache binds295	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));296297	for member in members {298		match member {299			Member::Field(field) => {300				evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;301			}302			Member::AssertStmt(stmt) => {303				#[derive(Trace)]304				struct ObjectAssert<B: Trace> {305					uctx: B,306					assert: AssertStmt,307				}308				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {309					fn run(&self, sup_this: SupThis) -> Result<()> {310						let ctx = self.uctx.bind(sup_this)?;311						evaluate_assert(ctx, &self.assert)312					}313				}314				builder.assert(ObjectAssert {315					uctx: uctx.clone(),316					assert: stmt.clone(),317				});318			}319			Member::BindStmt(_) => {320				// Already handled321			}322		}323	}324	Ok(builder.build())325}326327pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {328	Ok(match object {329		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,330		ObjBody::ObjComp(obj) => {331			let mut builder = ObjValueBuilder::new();332			let locals = Rc::new(333				obj.pre_locals334					.iter()335					.chain(obj.post_locals.iter())336					.cloned()337					.collect::<Vec<_>>(),338			);339			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {340				let uctx = evaluate_object_locals(ctx.clone(), locals.clone());341342				evaluate_field_member(&mut builder, ctx, uctx, &obj.field)343			})?;344345			builder.build()346		}347	})348}349350pub fn evaluate_apply(351	ctx: Context,352	value: &LocExpr,353	args: &ArgsDesc,354	loc: CallLocation<'_>,355	tailstrict: bool,356) -> Result<Val> {357	let value = evaluate(ctx.clone(), value)?;358	Ok(match value {359		Val::Func(f) => {360			let body = || f.evaluate(ctx, loc, args, tailstrict);361			if tailstrict {362				body()?363			} else {364				in_frame(loc, || format!("function <{}> call", f.name()), body)?365			}366		}367		v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),368	})369}370371pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {372	let value = &assertion.0;373	let msg = &assertion.1;374	let assertion_result = in_frame(375		CallLocation::new(&value.span()),376		|| "assertion condition".to_owned(),377		|| bool::from_untyped(evaluate(ctx.clone(), value)?),378	)?;379	if !assertion_result {380		in_frame(381			CallLocation::new(&value.span()),382			|| "assertion failure".to_owned(),383			|| {384				if let Some(msg) = msg {385					bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));386				}387				bail!(AssertionFailed(Val::Null.to_string()?));388			},389		)?;390	}391	Ok(())392}393394pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {395	use Expr::*;396	Ok(match expr.expr() {397		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),398		_ => evaluate(ctx, expr)?,399	})400}401402#[allow(clippy::too_many_lines)]403pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {404	use Expr::*;405406	if let Some(trivial) = evaluate_trivial(expr) {407		return Ok(trivial);408	}409	let loc = expr.span();410	Ok(match expr.expr() {411		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),412		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),413		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),414		Literal(LiteralType::True) => Val::Bool(true),415		Literal(LiteralType::False) => Val::Bool(false),416		Literal(LiteralType::Null) => Val::Null,417		Parened(e) => evaluate(ctx, e)?,418		Str(v) => Val::string(v.clone()),419		Num(v) => Val::try_num(*v)?,420		// I have tried to remove special behavior from super by implementing standalone-super421		// expresion, but looks like this case still needs special treatment.422		//423		// Note that other jsonnet implementations will fail on `if value in (super)` expression,424		// because the standalone super literal is not supported, that is because in other425		// implementations `in super` treated differently from `in smth_else`.426		BinaryOp(field, BinaryOpType::In, e)427			if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>428		{429			let sup_this = ctx.try_sup_this()?;430			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.431			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.432			if !sup_this.has_super() {433				return Ok(Val::Bool(false));434			}435			let field = evaluate(ctx, field)?;436			Val::Bool(sup_this.field_in_super(field.to_string()?))437		}438		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,439		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,440		Var(name) => in_frame(441			CallLocation::new(&loc),442			|| format!("local <{name}> access"),443			|| ctx.binding(name.clone())?.evaluate(),444		)?,445		Index { indexable, parts } => ensure_sufficient_stack(|| {446			let mut parts = parts.iter();447			let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {448				let part = parts.next().expect("at least part should exist");449				// sup_this existence check might also be skipped here for null-coalesce...450				// But I believe this might cause errors.451				let sup_this = ctx.try_sup_this()?;452				if !sup_this.has_super() {453					#[cfg(feature = "exp-null-coaelse")]454					if part.null_coaelse {455						return Ok(Val::Null);456					}457					bail!(NoSuperFound)458				}459				let name = evaluate(ctx.clone(), &part.value)?;460461				let Val::Str(name) = name else {462					bail!(ValueIndexMustBeTypeGot(463						ValType::Obj,464						ValType::Str,465						name.value_type(),466					))467				};468469				let name = name.into_flat();470				match sup_this471					.get_super(name.clone())472					.with_description_src(&part.value, || format!("field <{name}> access"))?473				{474					Some(v) => v,475					#[cfg(feature = "exp-null-coaelse")]476					None if part.null_coaelse => return Ok(Val::Null),477					None => {478						let suggestions = suggest_object_fields(479							&sup_this.standalone_super().expect("super exists"),480							name.clone(),481						);482483						bail!(NoSuchField(name, suggestions))484					}485				}486			} else {487				evaluate(ctx.clone(), indexable)?488			};489490			for part in parts {491				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {492					(Val::Obj(v), Val::Str(key)) => match v493						.get(key.clone().into_flat())494						.with_description_src(&part.value, || format!("field <{key}> access"))?495					{496						Some(v) => v,497						#[cfg(feature = "exp-null-coaelse")]498						None if part.null_coaelse => return Ok(Val::Null),499						None => {500							let suggestions = suggest_object_fields(&v, key.clone().into_flat());501502							return Err(Error::from(NoSuchField(503								key.clone().into_flat(),504								suggestions,505							)))506							.with_description_src(&part.value, || format!("field <{key}> access"));507						}508					},509					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(510						ValType::Obj,511						ValType::Str,512						n.value_type(),513					)),514					(Val::Arr(v), Val::Num(n)) => {515						let n = n.get();516						if n.fract() > f64::EPSILON {517							bail!(FractionalIndex)518						}519						if n < 0.0 {520							bail!(ArrayBoundsError(n as isize, v.len()));521						}522						v.get(n as usize)?523							.ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?524					}525					(Val::Arr(_), Val::Str(n)) => {526						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))527					}528					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(529						ValType::Arr,530						ValType::Num,531						n.value_type(),532					)),533534					(Val::Str(s), Val::Num(n)) => Val::Str({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, s.into_flat().chars().count()));541						}542						let v: IStr = s543							.clone()544							.into_flat()545							.chars()546							.skip(n as usize)547							.take(1)548							.collect::<String>()549							.into();550						if v.is_empty() {551							bail!(StringBoundsError(n as usize, s.into_flat().chars().count()))552						}553						StrValue::Flat(v)554					}),555					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(556						ValType::Str,557						ValType::Num,558						n.value_type(),559					)),560					#[cfg(feature = "exp-null-coaelse")]561					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),562					(v, _) => bail!(CantIndexInto(v.value_type())),563				};564			}565			Ok(indexable)566		})?,567		LocalExpr(bindings, returned) => {568			let mut new_bindings: FxHashMap<IStr, Thunk<Val>> =569				FxHashMap::with_capacity(bindings.iter().map(BindSpec::capacity_hint).sum());570			let fctx = Context::new_future();571			for b in bindings {572				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;573			}574			let ctx = ctx.extend_bindings(new_bindings).into_future(fctx);575			evaluate(ctx, &returned.clone())?576		}577		Arr(items) => {578			if items.is_empty() {579				Val::Arr(ArrValue::empty())580			} else if items.len() == 1 {581				let item = items[0].clone();582				Val::Arr(ArrValue::lazy(vec![Thunk!(move || evaluate(ctx, &item))]))583			} else {584				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))585			}586		}587		ArrComp(expr, comp_specs) => {588			let mut out = Vec::new();589			evaluate_comp(ctx, comp_specs, &mut |ctx| {590				let expr = expr.clone();591				out.push(Thunk!(move || evaluate(ctx, &expr)));592				Ok(())593			})?;594			Val::Arr(ArrValue::lazy(out))595		}596		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),597		ObjExtend(a, b) => evaluate_add_op(598			&evaluate(ctx.clone(), a)?,599			&Val::Obj(evaluate_object(ctx, b)?),600		)?,601		Apply(value, args, tailstrict) => ensure_sufficient_stack(|| {602			evaluate_apply(ctx, value, args, CallLocation::new(&loc), *tailstrict)603		})?,604		Function(params, body) => {605			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())606		}607		AssertExpr(assert, returned) => {608			evaluate_assert(ctx.clone(), assert)?;609			evaluate(ctx, returned)?610		}611		ErrorStmt(e) => in_frame(612			CallLocation::new(&loc),613			|| "error statement".to_owned(),614			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),615		)?,616		IfElse {617			cond,618			cond_then,619			cond_else,620		} => {621			if in_frame(622				CallLocation::new(&loc),623				|| "if condition".to_owned(),624				|| bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),625			)? {626				evaluate(ctx, cond_then)?627			} else {628				match cond_else {629					Some(v) => evaluate(ctx, v)?,630					None => Val::Null,631				}632			}633		}634		Slice(value, desc) => {635			fn parse_idx<T: Typed>(636				loc: CallLocation<'_>,637				ctx: Context,638				expr: Option<&LocExpr>,639				desc: &'static str,640			) -> Result<Option<T>> {641				if let Some(value) = expr {642					Ok(in_frame(643						loc,644						|| format!("slice {desc}"),645						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),646					)?)647				} else {648					Ok(None)649				}650			}651652			let indexable = evaluate(ctx.clone(), value)?;653			let loc = CallLocation::new(&loc);654655			let start = parse_idx(loc, ctx.clone(), desc.start.as_ref(), "start")?;656			let end = parse_idx(loc, ctx.clone(), desc.end.as_ref(), "end")?;657			let step = parse_idx(loc, ctx, desc.step.as_ref(), "step")?;658659			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?660		}661		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {662			let Expr::Str(path) = &path.expr() else {663				bail!("computed imports are not supported")664			};665			let tmp = loc.clone().0;666			with_state(|s| {667				let resolved_path = s.resolve_from(tmp.source_path(), path)?;668				Ok(match i {669					Import(_) => in_frame(670						CallLocation::new(&loc),671						|| format!("import {:?}", path.clone()),672						|| s.import_resolved(resolved_path),673					)?,674					ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),675					ImportBin(_) => {676						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))677					}678					_ => unreachable!(),679				}) as Result<Val>680			})?681		}682	})683}