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

1use std::rc::Rc;23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6	function::ParamName, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams,7	FieldMember, FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers,8	Spanned,9};10use jrsonnet_types::ValType;11use rustc_hash::FxHashMap;1213use self::destructure::destruct;14use crate::{15	arr::ArrValue,16	bail,17	destructure::evaluate_dest,18	error::{suggest_object_fields, ErrorKind::*},19	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},20	function::{CallLocation, FuncDesc, FuncVal},21	gc::WithCapacityExt as _,22	in_frame,23	typed::Typed,24	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},25	with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,26	ResultExt, SupThis, Unbound, Val,27};28pub mod destructure;29pub mod operator;3031// This is the amount of bytes that need to be left on the stack before increasing the size.32// It must be at least as large as the stack required by any code that does not call33// `ensure_sufficient_stack`.34const RED_ZONE: usize = 100 * 1024; // 100k3536// Only the first stack that is pushed, grows exponentially (2^n * STACK_PER_RECURSION) from then37// on. This flag has performance relevant characteristics. Don't set it too high.38const STACK_PER_RECURSION: usize = 1024 * 1024; // 1MB3940/// Grows the stack on demand to prevent stack overflow. Call this in strategic locations41/// to "break up" recursive calls. E.g. almost any call to `visit_expr` or equivalent can benefit42/// from this.43///44/// Should not be sprinkled around carelessly, as it causes a little bit of overhead.45#[inline]46pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {47	stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)48}4950pub fn evaluate_trivial(expr: &Spanned<Expr>) -> Option<Val> {51	fn is_trivial(expr: &Spanned<Expr>) -> bool {52		match &**expr {53			Expr::Str(_)54			| Expr::Num(_)55			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,56			Expr::Arr(a) => a.iter().all(is_trivial),57			_ => false,58		}59	}60	Some(match &**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		_ => return None,80	})81}8283pub fn evaluate_method(84	ctx: Context,85	name: IStr,86	params: ExprParams,87	body: Rc<Spanned<Expr>>,88) -> Val {89	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {90		name,91		ctx,92		params,93		body,94	})))95}9697pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {98	Ok(match field_name {99		FieldName::Fixed(n) => Some(n.clone()),100		FieldName::Dyn(expr) => in_frame(101			CallLocation::new(&expr.span()),102			|| "evaluating field name".to_string(),103			|| {104				let value = evaluate(ctx, expr)?;105				if matches!(value, Val::Null) {106					Ok(None)107				} else {108					Ok(Some(IStr::from_untyped(value)?))109				}110			},111		)?,112	})113}114115pub fn evaluate_comp(116	ctx: Context,117	specs: &[CompSpec],118	callback: &mut impl FnMut(Context) -> Result<()>,119) -> Result<()> {120	match specs.first() {121		None => callback(ctx)?,122		Some(CompSpec::IfSpec(IfSpecData(cond))) => {123			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {124				evaluate_comp(ctx, &specs[1..], callback)?;125			}126		}127		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {128			Val::Arr(list) => {129				for item in list.iter_lazy() {130					let fctx = Pending::new();131					let mut new_bindings = FxHashMap::with_capacity(var.binds_len());132					destruct(var, item, fctx.clone(), &mut new_bindings)?;133					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);134135					evaluate_comp(ctx, &specs[1..], callback)?;136				}137			}138			#[cfg(feature = "exp-object-iteration")]139			Val::Obj(obj) => {140				for field in obj.fields(141					// TODO: Should there be ability to preserve iteration order?142					#[cfg(feature = "exp-preserve-order")]143					false,144				) {145					let fctx = Pending::new();146					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());147					let obj = obj.clone();148					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![149						Thunk::evaluated(Val::string(field.clone())),150						Thunk!(move || obj.get(field).transpose().expect(151							"field exists, as field name was obtained from object.fields()",152						)),153					])));154					destruct(var, value, fctx.clone(), &mut new_bindings)?;155					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);156157					evaluate_comp(ctx, &specs[1..], callback)?;158				}159			}160			_ => bail!(InComprehensionCanOnlyIterateOverArray),161		},162	}163	Ok(())164}165166trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}167impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}168169fn evaluate_object_locals(170	fctx: Context,171	locals: Rc<Vec<BindSpec>>,172) -> impl CloneableUnbound<Context> {173	#[derive(Trace, Clone)]174	struct UnboundLocals {175		fctx: Context,176		locals: Rc<Vec<BindSpec>>,177	}178	impl Unbound for UnboundLocals {179		type Bound = Context;180181		fn bind(&self, sup_this: SupThis) -> Result<Context> {182			let fctx = Context::new_future();183			let mut new_bindings =184				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::binds_len).sum());185			for b in self.locals.iter() {186				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;187			}188189			let ctx = self.fctx.clone();190191			let ctx = ctx192				.extend_bindings_sup_this(new_bindings, sup_this)193				.into_future(fctx);194195			Ok(ctx)196		}197	}198199	UnboundLocals { fctx, locals }200}201202pub fn evaluate_field_member<B: Unbound<Bound = Context> + Clone>(203	builder: &mut ObjValueBuilder,204	ctx: Context,205	uctx: B,206	field: &FieldMember,207) -> Result<()> {208	let name = evaluate_field_name(ctx, &field.name)?;209	let Some(name) = name else {210		return Ok(());211	};212213	match field {214		FieldMember {215			plus,216			params: None,217			visibility,218			value,219			..220		} => {221			#[derive(Trace)]222			struct UnboundValue<B: Trace> {223				uctx: B,224				value: Rc<Spanned<Expr>>,225				name: IStr,226			}227			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {228				type Bound = Val;229				fn bind(&self, sup_this: SupThis) -> Result<Val> {230					evaluate_named(self.uctx.bind(sup_this)?, &self.value, self.name.clone())231				}232			}233234			builder235				.field(name.clone())236				.with_add(*plus)237				.with_visibility(*visibility)238				.with_location(value.span())239				.bindable(UnboundValue {240					uctx,241					value: value.clone(),242					name,243				})?;244		}245		FieldMember {246			params: Some(params),247			visibility,248			value,249			..250		} => {251			#[derive(Trace)]252			struct UnboundMethod<B: Trace> {253				uctx: B,254				value: Rc<Spanned<Expr>>,255				params: ExprParams,256				name: IStr,257			}258			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {259				type Bound = Val;260				fn bind(&self, sup_this: SupThis) -> Result<Val> {261					Ok(evaluate_method(262						self.uctx.bind(sup_this)?,263						self.name.clone(),264						self.params.clone(),265						self.value.clone(),266					))267				}268			}269270			builder271				.field(name.clone())272				.with_visibility(*visibility)273				.with_location(value.span())274				.bindable(UnboundMethod {275					uctx,276					value: value.clone(),277					params: params.clone(),278					name,279				})?;280		}281	}282	Ok(())283}284285#[allow(clippy::too_many_lines)]286pub fn evaluate_member_list_object(ctx: Context, members: &ObjMembers) -> Result<ObjValue> {287	let mut builder = ObjValueBuilder::new();288	let locals = members.locals.clone();289290	// We have single context for all fields, so we can cache binds291	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));292293	for field in &members.fields {294		evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), &field)?;295	}296297	if !members.asserts.is_empty() {298		#[derive(Trace)]299		struct ObjectAssert<B: Trace> {300			uctx: B,301			asserts: Rc<Vec<AssertStmt>>,302		}303		impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {304			fn run(&self, sup_this: SupThis) -> Result<()> {305				let ctx = self.uctx.bind(sup_this)?;306				for assert in &*self.asserts {307					evaluate_assert(ctx.clone(), &assert)?;308				}309				Ok(())310			}311		}312		builder.assert(ObjectAssert {313			uctx: uctx.clone(),314			asserts: members.asserts.clone(),315		});316	}317318	Ok(builder.build())319}320321pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {322	Ok(match object {323		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,324		ObjBody::ObjComp(obj) => {325			let mut builder = ObjValueBuilder::new();326			let locals = obj.locals.clone();327			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {328				let uctx = evaluate_object_locals(ctx.clone(), locals.clone());329330				evaluate_field_member(&mut builder, ctx, uctx, &obj.field)331			})?;332333			builder.build()334		}335	})336}337338pub fn evaluate_apply(339	ctx: Context,340	value: &Spanned<Expr>,341	args: &ArgsDesc,342	loc: CallLocation<'_>,343	tailstrict: bool,344) -> Result<Val> {345	let value = evaluate(ctx.clone(), value)?;346	Ok(match value {347		Val::Func(f) => {348			let body = || f.evaluate(ctx, loc, args, tailstrict);349			if tailstrict {350				body()?351			} else {352				in_frame(loc, || format!("function <{}> call", f.name()), body)?353			}354		}355		v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),356	})357}358359pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {360	let value = &assertion.0;361	let msg = &assertion.1;362	let assertion_result = in_frame(363		CallLocation::new(&value.span()),364		|| "assertion condition".to_owned(),365		|| bool::from_untyped(evaluate(ctx.clone(), value)?),366	)?;367	if !assertion_result {368		in_frame(369			CallLocation::new(&value.span()),370			|| "assertion failure".to_owned(),371			|| {372				if let Some(msg) = msg {373					bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));374				}375				bail!(AssertionFailed(Val::Null.to_string()?));376			},377		)?;378	}379	Ok(())380}381382pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {383	match name {384		ParamName::Named(name) => evaluate_named(ctx, expr, name),385		ParamName::Unnamed => evaluate(ctx, expr),386	}387}388389pub fn evaluate_named(ctx: Context, expr: &Spanned<Expr>, name: IStr) -> Result<Val> {390	use Expr::*;391	Ok(match &**expr {392		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),393		_ => evaluate(ctx, expr)?,394	})395}396397#[allow(clippy::too_many_lines)]398pub fn evaluate(ctx: Context, expr: &Spanned<Expr>) -> Result<Val> {399	use Expr::*;400401	if let Some(trivial) = evaluate_trivial(expr) {402		return Ok(trivial);403	}404	let loc = expr.span();405	Ok(match &**expr {406		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),407		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),408		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),409		Literal(LiteralType::True) => Val::Bool(true),410		Literal(LiteralType::False) => Val::Bool(false),411		Literal(LiteralType::Null) => Val::Null,412		Str(v) => Val::string(v.clone()),413		Num(v) => Val::try_num(*v)?,414		// I have tried to remove special behavior from super by implementing standalone-super415		// expresion, but looks like this case still needs special treatment.416		//417		// Note that other jsonnet implementations will fail on `if value in (super)` expression,418		// because the standalone super literal is not supported, that is because in other419		// implementations `in super` treated differently from `in smth_else`.420		BinaryOp(bin)421			if matches!(&*bin.rhs, Expr::Literal(LiteralType::Super))422				&& bin.op == BinaryOpType::In =>423		{424			let sup_this = ctx.try_sup_this()?;425			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.426			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.427			if !sup_this.has_super() {428				return Ok(Val::Bool(false));429			}430			let field = evaluate(ctx, &bin.lhs)?;431			Val::Bool(sup_this.field_in_super(field.to_string()?))432		}433		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,434		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,435		Var(name) => in_frame(436			CallLocation::new(&loc),437			|| format!("local <{name}> access"),438			|| ctx.binding(name.clone())?.evaluate(),439		)?,440		Index { indexable, parts } => ensure_sufficient_stack(|| {441			let mut parts = parts.iter();442			let mut indexable = if matches!(&***indexable, Expr::Literal(LiteralType::Super)) {443				let part = parts.next().expect("at least part should exist");444				// sup_this existence check might also be skipped here for null-coalesce...445				// But I believe this might cause errors.446				let sup_this = ctx.try_sup_this()?;447				if !sup_this.has_super() {448					#[cfg(feature = "exp-null-coaelse")]449					if part.null_coaelse {450						return Ok(Val::Null);451					}452					bail!(NoSuperFound)453				}454				let name = evaluate(ctx.clone(), &part.value)?;455456				let Val::Str(name) = name else {457					bail!(ValueIndexMustBeTypeGot(458						ValType::Obj,459						ValType::Str,460						name.value_type(),461					))462				};463464				let name = name.into_flat();465				match sup_this466					.get_super(name.clone())467					.with_description_src(&part.value, || format!("field <{name}> access"))?468				{469					Some(v) => v,470					#[cfg(feature = "exp-null-coaelse")]471					None if part.null_coaelse => return Ok(Val::Null),472					None => {473						let suggestions = suggest_object_fields(474							&sup_this.standalone_super().expect("super exists"),475							name.clone(),476						);477478						bail!(NoSuchField(name, suggestions))479					}480				}481			} else {482				evaluate(ctx.clone(), indexable)?483			};484485			for part in parts {486				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {487					(Val::Obj(v), Val::Str(key)) => match v488						.get(key.clone().into_flat())489						.with_description_src(&part.value, || format!("field <{key}> access"))?490					{491						Some(v) => v,492						#[cfg(feature = "exp-null-coaelse")]493						None if part.null_coaelse => return Ok(Val::Null),494						None => {495							let suggestions = suggest_object_fields(&v, key.clone().into_flat());496497							return Err(Error::from(NoSuchField(498								key.clone().into_flat(),499								suggestions,500							)))501							.with_description_src(&part.value, || format!("field <{key}> access"));502						}503					},504					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(505						ValType::Obj,506						ValType::Str,507						n.value_type(),508					)),509					(Val::Arr(v), Val::Num(n)) => {510						let n = n.get();511						if n.fract() > f64::EPSILON {512							bail!(FractionalIndex)513						}514						if n < 0.0 {515							bail!(ArrayBoundsError(n as isize, v.len()));516						}517						v.get(n as usize)?518							.ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?519					}520					(Val::Arr(_), Val::Str(n)) => {521						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))522					}523					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(524						ValType::Arr,525						ValType::Num,526						n.value_type(),527					)),528529					(Val::Str(s), Val::Num(n)) => Val::Str({530						let n = n.get();531						if n.fract() > f64::EPSILON {532							bail!(FractionalIndex)533						}534						if n < 0.0 {535							bail!(ArrayBoundsError(n as isize, s.into_flat().chars().count()));536						}537						let v: IStr = s538							.clone()539							.into_flat()540							.chars()541							.skip(n as usize)542							.take(1)543							.collect::<String>()544							.into();545						if v.is_empty() {546							bail!(StringBoundsError(n as usize, s.into_flat().chars().count()))547						}548						StrValue::Flat(v)549					}),550					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(551						ValType::Str,552						ValType::Num,553						n.value_type(),554					)),555					#[cfg(feature = "exp-null-coaelse")]556					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),557					(v, _) => bail!(CantIndexInto(v.value_type())),558				};559			}560			Ok(indexable)561		})?,562		LocalExpr(bindings, returned) => {563			let mut new_bindings: FxHashMap<IStr, Thunk<Val>> =564				FxHashMap::with_capacity(bindings.iter().map(BindSpec::binds_len).sum());565			let fctx = Context::new_future();566			for b in bindings {567				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;568			}569			let ctx = ctx.extend_bindings(new_bindings).into_future(fctx);570			evaluate(ctx, &returned.clone())?571		}572		Arr(items) => {573			if items.is_empty() {574				Val::Arr(ArrValue::empty())575			} else {576				Val::Arr(ArrValue::expr(ctx, items.clone()))577			}578		}579		ArrComp(expr, comp_specs) => {580			let mut out = Vec::new();581			evaluate_comp(ctx, comp_specs, &mut |ctx| {582				let expr = expr.clone();583				out.push(Thunk!(move || evaluate(ctx, &expr)));584				Ok(())585			})?;586			Val::Arr(ArrValue::lazy(out))587		}588		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),589		ObjExtend(a, b) => evaluate_add_op(590			&evaluate(ctx.clone(), a)?,591			&Val::Obj(evaluate_object(ctx, b)?),592		)?,593		Apply(value, args, tailstrict) => ensure_sufficient_stack(|| {594			evaluate_apply(ctx, value, args, CallLocation::new(&loc), *tailstrict)595		})?,596		Function(params, body) => {597			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())598		}599		AssertExpr(assert) => {600			evaluate_assert(ctx.clone(), &assert.assert)?;601			evaluate(ctx, &assert.rest)?602		}603		ErrorStmt(e) => in_frame(604			CallLocation::new(&loc),605			|| "error statement".to_owned(),606			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),607		)?,608		IfElse(if_else) => {609			if in_frame(610				CallLocation::new(&loc),611				|| "if condition".to_owned(),612				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?),613			)? {614				evaluate(ctx, &if_else.cond_then)?615			} else {616				match &if_else.cond_else {617					Some(v) => evaluate(ctx, v)?,618					None => Val::Null,619				}620			}621		}622		Slice(slice) => {623			fn parse_idx<T: Typed>(624				loc: CallLocation<'_>,625				ctx: Context,626				expr: Option<&Spanned<Expr>>,627				desc: &'static str,628			) -> Result<Option<T>> {629				if let Some(value) = expr {630					Ok(in_frame(631						loc,632						|| format!("slice {desc}"),633						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),634					)?)635				} else {636					Ok(None)637				}638			}639640			let indexable = evaluate(ctx.clone(), &slice.value)?;641			let loc = CallLocation::new(&loc);642643			let start = parse_idx(loc, ctx.clone(), slice.slice.start.as_ref(), "start")?;644			let end = parse_idx(loc, ctx.clone(), slice.slice.end.as_ref(), "end")?;645			let step = parse_idx(loc, ctx, slice.slice.step.as_ref(), "step")?;646647			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?648		}649		Import(kind, path) => {650			let Expr::Str(path) = &***path else {651				bail!("computed imports are not supported")652			};653			let tmp = loc.clone().0;654			with_state(|s| {655				let resolved_path = s.resolve_from(tmp.source_path(), path)?;656				Ok(match kind {657					ImportKind::Normal => in_frame(658						CallLocation::new(&loc),659						|| format!("import {:?}", path.clone()),660						|| s.import_resolved(resolved_path),661					)?,662					ImportKind::Str => Val::string(s.import_resolved_str(resolved_path)?),663					ImportKind::Bin => {664						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))665					}666				}) as Result<Val>667			})?668		}669	})670}