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

1use std::rc::Rc;23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_ir::{6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams, FieldMember,7	FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers, Spanned,8	function::ParamName,9};10use jrsonnet_types::ValType;1112use self::destructure::destruct;13use crate::{14	Context, ContextBuilder, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,15	ResultExt, SupThis, Unbound, Val,16	arr::ArrValue,17	bail,18	destructure::evaluate_dest,19	error::{ErrorKind::*, suggest_object_fields},20	evaluate::operator::{evaluate_binary_op_special, evaluate_unary_op},21	function::{CallLocation, FuncDesc, FuncVal, PreparedFuncVal},22	in_frame,23	typed::{FromUntyped, IntoUntyped as _, Typed},24	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},25	with_state,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: &Expr) -> Option<Val> {50	fn is_trivial(expr: &Expr) -> bool {51		match 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			_ => false,57		}58	}59	Some(match expr {60		Expr::Str(s) => Val::string(s.clone()),61		Expr::Num(n) => {62			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))63		}64		Expr::Literal(LiteralType::False) => Val::Bool(false),65		Expr::Literal(LiteralType::True) => Val::Bool(true),66		Expr::Literal(LiteralType::Null) => Val::Null,67		Expr::Arr(n) => {68			if n.iter().any(|e| !is_trivial(e)) {69				return None;70			}71			Val::Arr(72				n.iter()73					.map(evaluate_trivial)74					.map(|e| e.expect("checked trivial"))75					.collect(),76			)77		}78		_ => return None,79	})80}8182pub fn evaluate_method(ctx: Context, name: IStr, params: ExprParams, body: Rc<Expr>) -> Val {83	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {84		name,85		ctx,86		params,87		body,88	})))89}9091pub fn evaluate_field_name(ctx: Context, field_name: &Spanned<FieldName>) -> Result<Option<IStr>> {92	Ok(match &field_name.value {93		FieldName::Fixed(n) => Some(n.clone()),94		FieldName::Dyn(expr) => in_frame(95			CallLocation::new(&field_name.span),96			|| "evaluating field name".to_string(),97			|| {98				let v = evaluate(ctx, expr)?;99				Ok(if matches!(v, Val::Null) {100					None101				} else {102					Some(IStr::from_untyped(v)?)103				})104			},105		)?,106	})107}108109pub fn evaluate_comp(110	ctx: Context,111	specs: &[CompSpec],112	mut guaranteed_reserve: usize,113	callback: &mut impl FnMut(Context, usize) -> Result<()>,114) -> Result<()> {115	match specs.first() {116		None => callback(ctx, guaranteed_reserve)?,117		Some(CompSpec::IfSpec(IfSpecData { cond, span: _ })) => {118			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {119				evaluate_comp(ctx, &specs[1..], 0, callback)?;120			}121		}122		Some(CompSpec::ForSpec(ForSpecData {123			destruct: into,124			over,125		})) => {126			match evaluate(ctx.clone(), over)? {127				Val::Arr(list) => {128					guaranteed_reserve = guaranteed_reserve.max(1) * list.len();129					for (i, item) in list.iter_lazy().enumerate() {130						let fctx = Pending::new();131						let mut ctx = ContextBuilder::extend_fast(ctx.clone());132						destruct(into, item, fctx.clone(), &mut ctx)?;133						let ctx = ctx.build().into_future(fctx);134135						let specs = &specs[1..];136						evaluate_comp(137							ctx,138							specs,139							if i == 0 || !specs.is_empty() {140								guaranteed_reserve141							} else {142								0143							},144							callback,145						)?;146					}147				}148				Val::Obj(obj) if cfg!(feature = "exp-object-iteration") => {149					let fields = obj.fields(150						// TODO: Should there be ability to preserve iteration order?151						#[cfg(feature = "exp-preserve-order")]152						false,153					);154					guaranteed_reserve = guaranteed_reserve.max(1) * fields.len();155					for (i, field) in fields.into_iter().enumerate() {156						let fctx = Pending::new();157						let mut ctx = ContextBuilder::extend_fast(ctx.clone());158						let obj = obj.clone();159						let value = Thunk::evaluated(Val::arr(vec![160							Thunk::evaluated(Val::string(field.clone())),161							obj.get_lazy(field).expect(162								"field exists, as field name was obtained from object.fields()",163							),164						]));165						destruct(into, value, fctx.clone(), &mut ctx)?;166						let ctx = ctx.build().into_future(fctx);167168						evaluate_comp(169							ctx,170							&specs[1..],171							if i == 0 || !specs.is_empty() {172								guaranteed_reserve173							} else {174								0175							},176							callback,177						)?;178					}179				}180				_ => bail!(InComprehensionCanOnlyIterateOverArray),181			}182		}183	}184	Ok(())185}186187fn evaluate_arr_comp(ctx: Context, expr: &Rc<Expr>, comp_specs: &[CompSpec]) -> Result<ArrValue> {188	let ctx = ctx.branch_point();189	'eager: {190		let mut out = Vec::new();191192		if evaluate_comp(ctx.clone(), comp_specs, 0, &mut |ctx, reserve| {193			if reserve != 0 {194				out.reserve(reserve);195			}196			out.push(evaluate(ctx, expr)?);197			Ok(())198		})199		.is_err()200		{201			break 'eager;202		}203204		return Ok(ArrValue::new(out));205	};206	let mut out = Vec::new();207	evaluate_comp(ctx, comp_specs, 0, &mut |ctx, reserve| {208		if reserve != 0 {209			out.reserve(reserve);210		}211		let expr = expr.clone();212		out.push(Thunk!(move || evaluate(ctx, &expr)));213		Ok(())214	})?;215	Ok(ArrValue::new(out))216}217218trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}219impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}220221fn evaluate_object_locals(222	fctx: Context,223	locals: Rc<Vec<BindSpec>>,224) -> impl CloneableUnbound<Context> {225	#[derive(Trace, Clone)]226	struct UnboundLocals {227		fctx: Context,228		locals: Rc<Vec<BindSpec>>,229	}230	impl Unbound for UnboundLocals {231		type Bound = Context;232233		fn bind(&self, sup_this: SupThis) -> Result<Context> {234			let fctx = Context::new_future();235			let ctx = self.fctx.clone();236			let mut ctx = ContextBuilder::extend(ctx);237			for b in self.locals.iter() {238				evaluate_dest(b, fctx.clone(), &mut ctx)?;239			}240241			let ctx = ctx.build_sup_this(sup_this).into_future(fctx);242243			Ok(ctx)244		}245	}246247	UnboundLocals { fctx, locals }248}249250pub fn evaluate_field_member<B: Unbound<Bound = Context> + Clone>(251	builder: &mut ObjValueBuilder,252	ctx: Context,253	uctx: B,254	field: &FieldMember,255) -> Result<()> {256	let name = evaluate_field_name(ctx, &field.name)?;257	let Some(name) = name else {258		return Ok(());259	};260261	match field {262		FieldMember {263			plus,264			params: None,265			visibility,266			value,267			..268		} => {269			#[derive(Trace)]270			struct UnboundValue<B: Trace> {271				uctx: B,272				value: Rc<Expr>,273				name: IStr,274			}275			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {276				type Bound = Val;277				fn bind(&self, sup_this: SupThis) -> Result<Val> {278					evaluate_named(self.uctx.bind(sup_this)?, &self.value, self.name.clone())279				}280			}281282			builder283				.field(name.clone())284				.with_add(*plus)285				.with_visibility(*visibility)286				.with_location(field.name.span.clone())287				.bindable(UnboundValue {288					uctx,289					value: value.clone(),290					name,291				})?;292		}293		FieldMember {294			params: Some(params),295			visibility,296			value,297			..298		} => {299			#[derive(Trace)]300			struct UnboundMethod<B: Trace> {301				uctx: B,302				value: Rc<Expr>,303				params: ExprParams,304				name: IStr,305			}306			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {307				type Bound = Val;308				fn bind(&self, sup_this: SupThis) -> Result<Val> {309					Ok(evaluate_method(310						self.uctx.bind(sup_this)?,311						self.name.clone(),312						self.params.clone(),313						self.value.clone(),314					))315				}316			}317318			builder319				.field(name.clone())320				.with_visibility(*visibility)321				// .with_location(value.span())322				.bindable(UnboundMethod {323					uctx,324					value: value.clone(),325					params: params.clone(),326					name,327				})?;328		}329	}330	Ok(())331}332333#[derive(Trace, Clone)]334struct DirectUnbound(Context);335impl Unbound for DirectUnbound {336	type Bound = Context;337	fn bind(&self, sup_this: SupThis) -> Result<Context> {338		Ok(ContextBuilder::extend(self.0.clone()).build_sup_this(sup_this))339	}340}341342#[allow(clippy::too_many_lines)]343pub fn evaluate_member_list_object(344	super_obj: Option<ObjValue>,345	ctx: Context,346	members: &ObjMembers,347) -> Result<ObjValue> {348	#[derive(Trace)]349	struct ObjectAssert<B: Trace> {350		uctx: B,351		asserts: Rc<Vec<AssertStmt>>,352	}353	impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {354		fn run(&self, sup_this: SupThis) -> Result<()> {355			let ctx = self.uctx.bind(sup_this)?;356			for assert in &*self.asserts {357				evaluate_assert(ctx.clone(), assert)?;358			}359			Ok(())360		}361	}362363	let mut builder = ObjValueBuilder::new();364	if let Some(super_obj) = super_obj {365		builder.with_super(super_obj);366	}367368	if members.locals.is_empty() {369		// We can use the same context for all field evaluation, it doesn't depends on locals, only on this/super370		let uctx = DirectUnbound(ctx.clone());371		for field in &members.fields {372			evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;373		}374		if !members.asserts.is_empty() {375			builder.assert(ObjectAssert {376				uctx,377				asserts: members.asserts.clone(),378			});379		}380	} else {381		let locals = members.locals.clone();382		// We have single context for all fields, so we can cache them together383		let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));384		for field in &members.fields {385			evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;386		}387		if !members.asserts.is_empty() {388			builder.assert(ObjectAssert {389				uctx,390				asserts: members.asserts.clone(),391			});392		}393	}394395	Ok(builder.build())396}397398pub fn evaluate_object(399	super_obj: Option<ObjValue>,400	ctx: Context,401	object: &ObjBody,402) -> Result<ObjValue> {403	Ok(match object {404		ObjBody::MemberList(members) => evaluate_member_list_object(super_obj, ctx, members)?,405		ObjBody::ObjComp(obj) => {406			let mut builder = ObjValueBuilder::new();407			if let Some(super_obj) = super_obj {408				builder.with_super(super_obj);409			}410			let locals = obj.locals.clone();411			evaluate_comp(412				ctx.branch_point(),413				&obj.compspecs,414				0,415				&mut |ctx, reserve| {416					let uctx = evaluate_object_locals(ctx.clone(), locals.clone());417					builder.reserve_fields(reserve);418419					evaluate_field_member(&mut builder, ctx, uctx, &obj.field)420				},421			)?;422423			builder.build()424		}425	})426}427428pub fn evaluate_apply(429	ctx: Context,430	value: &Expr,431	args: &ArgsDesc,432	loc: CallLocation<'_>,433	tailstrict: bool,434) -> Result<Val> {435	let value = evaluate(ctx.clone(), value)?;436	Ok(match value {437		Val::Func(f) => {438			let name = f.name();439			let unnamed = args440				.unnamed441				.iter()442				.cloned()443				.map(|un| evaluate_thunk(ctx.clone(), un, tailstrict))444				.collect::<Result<Vec<_>>>()?;445			let named = args446				.values447				.iter()448				.cloned()449				.map(|un| evaluate_thunk(ctx.clone(), un, tailstrict))450				.collect::<Result<Vec<_>>>()?;451			let prepare = PreparedFuncVal::new(f, args.unnamed.len(), &args.names)452				.with_description_src(loc, || format!("function <{name}> call"))?;453			let body = || prepare.call(loc, &unnamed, &named);454			if tailstrict {455				body()?456			} else {457				in_frame(loc, || format!("function <{name}> call"), body)?458			}459		}460		v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),461	})462}463464pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {465	let AssertStmt { assertion, message } = assertion;466	let assertion_result = in_frame(467		CallLocation::new(&assertion.span),468		|| "assertion condition".to_owned(),469		|| bool::from_untyped(evaluate(ctx.clone(), assertion)?),470	)?;471	if !assertion_result {472		in_frame(473			CallLocation::new(&assertion.span),474			|| "assertion failure".to_owned(),475			|| {476				if let Some(msg) = message {477					bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));478				}479				bail!(AssertionFailed(Val::Null.to_string()?));480			},481		)?;482	}483	Ok(())484}485486pub fn evaluate_named_param(ctx: Context, expr: &Expr, name: ParamName) -> Result<Val> {487	match name {488		ParamName::Named(name) => evaluate_named(ctx, expr, name),489		ParamName::Unnamed => evaluate(ctx, expr),490	}491}492493pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {494	use Expr::*;495	Ok(match expr {496		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),497		_ => evaluate(ctx, expr)?,498	})499}500501pub fn evaluate_thunk(ctx: Context, expr: Rc<Expr>, tailstrict: bool) -> Result<Thunk<Val>> {502	Ok(if tailstrict {503		Thunk::evaluated(evaluate(ctx, &expr)?)504	} else {505		Thunk!(move || { evaluate(ctx, &expr) })506	})507}508#[allow(clippy::too_many_lines)]509pub fn evaluate(ctx: Context, expr: &Expr) -> Result<Val> {510	use Expr::*;511512	Ok(match expr {513		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),514		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),515		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),516		Literal(LiteralType::True) => Val::Bool(true),517		Literal(LiteralType::False) => Val::Bool(false),518		Literal(LiteralType::Null) => Val::Null,519		Str(v) => Val::string(v.clone()),520		Num(v) => Val::try_num(*v)?,521		// I have tried to remove special behavior from super by implementing standalone-super522		// expresion, but looks like this case still needs special treatment.523		//524		// Note that other jsonnet implementations will fail on `if value in (super)` expression,525		// because the standalone super literal is not supported, that is because in other526		// implementations `in super` treated differently from `in smth_else`.527		BinaryOp(bin)528			if matches!(&bin.rhs, Expr::Literal(LiteralType::Super))529				&& bin.op == BinaryOpType::In =>530		{531			let sup_this = ctx.try_sup_this()?;532			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.533			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.534			if !sup_this.has_super() {535				return Ok(Val::Bool(false));536			}537			let field = evaluate(ctx, &bin.lhs)?;538			Val::Bool(sup_this.field_in_super(field.to_string()?))539		}540		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,541		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,542		Var(name) => in_frame(543			CallLocation::new(&name.span),544			|| format!("local <{}> access", &**name),545			|| ctx.binding((**name).clone())?.evaluate(),546		)?,547		Index { indexable, parts } => ensure_sufficient_stack(|| {548			let mut parts = parts.iter();549			let mut indexable = if matches!(&**indexable, Expr::Literal(LiteralType::Super)) {550				let part = parts.next().expect("at least part should exist");551				// sup_this existence check might also be skipped here for null-coalesce...552				// But I believe this might cause errors.553				let sup_this = ctx.try_sup_this()?;554				if !sup_this.has_super() {555					#[cfg(feature = "exp-null-coaelse")]556					if part.null_coaelse {557						return Ok(Val::Null);558					}559					bail!(NoSuperFound)560				}561				let name = evaluate(ctx.clone(), &part.value)?;562563				let Val::Str(name) = name else {564					bail!(ValueIndexMustBeTypeGot(565						ValType::Obj,566						ValType::Str,567						name.value_type(),568					))569				};570571				let name = name.into_flat();572				match sup_this573					.get_super(name.clone())574					.with_description_src(&part.span, || format!("field <{name}> access"))?575				{576					Some(v) => v,577					#[cfg(feature = "exp-null-coaelse")]578					None if part.null_coaelse => return Ok(Val::Null),579					None => {580						let suggestions = suggest_object_fields(581							&sup_this.standalone_super().expect("super exists"),582							name.clone(),583						);584585						bail!(NoSuchField(name, suggestions))586					}587				}588			} else {589				evaluate(ctx.clone(), indexable)?590			};591592			for part in parts {593				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {594					(Val::Obj(v), Val::Str(key)) => match v595						.get(key.clone().into_flat())596						.with_description_src(&part.span, || format!("field <{key}> access"))?597					{598						Some(v) => v,599						#[cfg(feature = "exp-null-coaelse")]600						None if part.null_coaelse => return Ok(Val::Null),601						None => {602							let suggestions = suggest_object_fields(&v, key.into_flat());603604							return Err(Error::from(NoSuchField(605								key.clone().into_flat(),606								suggestions,607							)))608							.with_description_src(&part.span, || format!("field <{key}> access"));609						}610					},611					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(612						ValType::Obj,613						ValType::Str,614						n.value_type(),615					)),616					(Val::Arr(v), Val::Num(n)) => {617						let n = n.get();618						if n.fract() > f64::EPSILON {619							bail!(FractionalIndex)620						}621						if n < 0.0 {622							#[expect(623								clippy::cast_possible_truncation,624								reason = "it would be truncated anyway"625							)]626							let n = n as isize;627							bail!(ArrayBoundsError(n, v.len()));628						}629						#[expect(630							clippy::cast_possible_truncation,631							clippy::cast_sign_loss,632							reason = "n is checked postive"633						)]634						v.get(n as usize)?635							.ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?636					}637					(Val::Arr(_), Val::Str(n)) => {638						bail!(AttemptedIndexAnArrayWithString(n.into_flat()))639					}640					(Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(641						ValType::Arr,642						ValType::Num,643						n.value_type(),644					)),645646					(Val::Str(s), Val::Num(n)) => Val::Str({647						let n = n.get();648						if n.fract() > f64::EPSILON {649							bail!(FractionalIndex)650						}651						if n < 0.0 {652							#[expect(653								clippy::cast_possible_truncation,654								reason = "it would be truncated anyway"655							)]656							let n = n as isize;657							bail!(ArrayBoundsError(n, s.into_flat().chars().count()));658						}659						#[expect(660							clippy::cast_sign_loss,661							clippy::cast_possible_truncation,662							reason = "n is positive, overflow will truncate as expected"663						)]664						let n = n as usize;665						let v: IStr = s666							.clone()667							.into_flat()668							.chars()669							.skip(n)670							.take(1)671							.collect::<String>()672							.into();673						if v.is_empty() {674							bail!(StringBoundsError(n, s.into_flat().chars().count()))675						}676						StrValue::Flat(v)677					}),678					(Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(679						ValType::Str,680						ValType::Num,681						n.value_type(),682					)),683					#[cfg(feature = "exp-null-coaelse")]684					(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),685					(v, _) => bail!(CantIndexInto(v.value_type())),686				};687			}688			Ok(indexable)689		})?,690		LocalExpr(bindings, returned) => {691			let fctx = Context::new_future();692			let mut ctx = ContextBuilder::extend(ctx);693			for b in bindings {694				evaluate_dest(b, fctx.clone(), &mut ctx)?;695			}696			let ctx = ctx.build().into_future(fctx);697			evaluate(ctx, returned)?698		}699		Arr(items) => {700			if items.is_empty() {701				Val::arr(())702			} else {703				Val::Arr(ArrValue::expr(ctx, items.clone()))704			}705		}706		ArrComp(expr, comp_specs) => Val::Arr(evaluate_arr_comp(ctx, expr, comp_specs)?),707		Obj(body) => Val::Obj(evaluate_object(None, ctx, body)?),708		ObjExtend(a, b) => {709			let base = evaluate(ctx.clone(), a)?;710			match base {711				Val::Obj(base_obj) => Val::Obj(evaluate_object(Some(base_obj), ctx, b)?),712				_ => bail!("ObjExtend lhs should be an object value"),713			}714		}715		Apply(value, args, tailstrict) => ensure_sufficient_stack(|| {716			evaluate_apply(ctx, value, args, CallLocation::new(&args.span), *tailstrict)717		})?,718		Function(params, body) => {719			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())720		}721		AssertExpr(assert) => {722			evaluate_assert(ctx.clone(), &assert.assert)?;723			evaluate(ctx, &assert.rest)?724		}725		ErrorStmt(s, e) => in_frame(726			CallLocation::new(s),727			|| "error statement".to_owned(),728			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),729		)?,730		IfElse(if_else) => {731			if in_frame(732				CallLocation::new(&if_else.cond.span),733				|| "if condition".to_owned(),734				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.cond)?),735			)? {736				evaluate(ctx, &if_else.cond_then)?737			} else {738				match &if_else.cond_else {739					Some(v) => evaluate(ctx, v)?,740					None => Val::Null,741				}742			}743		}744		Slice(slice) => {745			fn parse_idx<T: Typed + FromUntyped>(746				ctx: Context,747				expr: Option<&Spanned<Expr>>,748				desc: &'static str,749			) -> Result<Option<T>> {750				if let Some(value) = expr {751					Ok(in_frame(752						CallLocation::new(&value.span),753						|| format!("slice {desc}"),754						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),755					)?)756				} else {757					Ok(None)758				}759			}760761			let indexable = evaluate(ctx.clone(), &slice.value)?;762763			let start = parse_idx(ctx.clone(), slice.slice.start.as_ref(), "start")?;764			let end = parse_idx(ctx.clone(), slice.slice.end.as_ref(), "end")?;765			let step = parse_idx(ctx, slice.slice.step.as_ref(), "step")?;766767			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?768		}769		Import(kind, path) => {770			let Expr::Str(path) = &**path else {771				bail!("computed imports are not supported")772			};773			with_state(|s| {774				let span = &kind.span;775				let resolved_path = s.resolve_from(span.0.source_path(), path)?;776				Ok(match &**kind {777					ImportKind::Normal => in_frame(778						CallLocation::new(span),779						|| format!("import {:?}", path.clone()),780						|| s.import_resolved(resolved_path),781					)?,782					ImportKind::Str => Val::string(s.import_resolved_str(resolved_path)?),783					ImportKind::Bin => Val::arr(s.import_resolved_bin(resolved_path)?),784				}) as Result<Val>785			})?786		}787	})788}