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

309source = "registry+https://github.com/rust-lang/crates.io-index"309source = "registry+https://github.com/rust-lang/crates.io-index"
310checksum = "9bda8e21c04aca2ae33ffc2fd8c23134f3cac46db123ba97bd9d3f3b8a4a85e1"310checksum = "9bda8e21c04aca2ae33ffc2fd8c23134f3cac46db123ba97bd9d3f3b8a4a85e1"
311
312[[package]]
313name = "educe"
314version = "0.6.0"
315source = "registry+https://github.com/rust-lang/crates.io-index"
316checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
317dependencies = [
318 "enum-ordinalize",
319 "proc-macro2",
320 "quote",
321 "syn",
322]
311323
312[[package]]324[[package]]
313name = "either"325name = "either"
339 "encoding_rs",351 "encoding_rs",
340]352]
353
354[[package]]
355name = "enum-ordinalize"
356version = "4.3.2"
357source = "registry+https://github.com/rust-lang/crates.io-index"
358checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
359dependencies = [
360 "enum-ordinalize-derive",
361]
362
363[[package]]
364name = "enum-ordinalize-derive"
365version = "4.3.2"
366source = "registry+https://github.com/rust-lang/crates.io-index"
367checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
368dependencies = [
369 "proc-macro2",
370 "quote",
371 "syn",
372]
341373
342[[package]]374[[package]]
343name = "equivalent"375name = "equivalent"
576dependencies = [608dependencies = [
577 "annotate-snippets",609 "annotate-snippets",
578 "anyhow",610 "anyhow",
611 "educe",
579 "hi-doc",612 "hi-doc",
580 "jrsonnet-gcmodule",613 "jrsonnet-gcmodule",
581 "jrsonnet-interner",614 "jrsonnet-interner",

57num-bigint = { workspace = true, features = ["serde"], optional = true }57num-bigint = { workspace = true, features = ["serde"], optional = true }
5858
59stacker = "0.1.23"59stacker = "0.1.23"
60educe = { version = "0.6.0", default-features = false, features = ["Clone", "Debug", "Eq", "Hash", "PartialEq"] }
6061
61[build-dependencies]62[build-dependencies]
62rustversion = "1.0.22"63rustversion = "1.0.22"

1use std::fmt::Debug;1use std::fmt::Debug;
22
3use educe::Educe;
3use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_gcmodule::{Cc, Trace};
4use jrsonnet_interner::IStr;5use jrsonnet_interner::IStr;
5use rustc_hash::FxHashMap;6use rustc_hash::FxHashMap;
67
7use crate::{8use crate::{
8	error::ErrorKind::*, gc::WithCapacityExt as _, map::LayeredHashMap, ObjValue, Pending, Result,9	error::ErrorKind::*, gc::WithCapacityExt as _, map::LayeredHashMap, ObjValue, Pending, Result,
9	Thunk, Val,10	SupThis, Thunk, Val,
10};11};
12/// Context keeps information about current lexical code location
13///
14/// This information includes local variables, top-level object (`$`), current object (`this`), and super object (`super`)
15#[derive(Debug, Trace, Clone, Educe)]
16#[educe(PartialEq)]
17pub struct Context(#[educe(PartialEq(method = Cc::ptr_eq))] Cc<ContextInternal>);
1118
12#[derive(Trace)]19#[derive(Debug, Trace)]
13struct ContextInternals {20struct ContextInternal {
14	dollar: Option<ObjValue>,21	dollar: Option<ObjValue>,
15	sup: Option<ObjValue>,22	sup_this: Option<SupThis>,
16	this: Option<ObjValue>,
17	bindings: LayeredHashMap,23	bindings: LayeredHashMap,
18}24}
19impl Debug for ContextInternals {
20	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21		f.debug_struct("Context").finish()
22	}
23}
24
25/// Context keeps information about current lexical code location
26///
27/// This information includes local variables, top-level object (`$`), current object (`this`), and super object (`super`)
28#[derive(Debug, Clone, Trace)]
29pub struct Context(Cc<ContextInternals>);
30impl Context {25impl Context {
31	pub fn new_future() -> Pending<Self> {26	pub fn new_future() -> Pending<Self> {
32		Pending::new()27		Pending::new()
36		self.0.dollar.as_ref()31		self.0.dollar.as_ref()
37	}32	}
33
34	pub fn try_dollar(&self) -> Result<ObjValue> {
35		self.0
36			.dollar
37			.clone()
38			.ok_or_else(|| CantUseSelfSupOutsideOfObject.into())
39	}
3840
39	pub fn this(&self) -> Option<&ObjValue> {41	pub fn this(&self) -> Option<&ObjValue> {
40		self.0.this.as_ref()42		self.0.sup_this.as_ref().map(SupThis::this)
41	}43	}
44
45	pub fn try_this(&self) -> Result<ObjValue> {
46		self.0
47			.sup_this
48			.as_ref()
49			.ok_or_else(|| CantUseSelfSupOutsideOfObject.into())
50			.map(SupThis::this)
51			.cloned()
52	}
4253
43	pub fn super_obj(&self) -> Option<&ObjValue> {54	pub fn sup_this(&self) -> Option<&SupThis> {
44		self.0.sup.as_ref()55		self.0.sup_this.as_ref()
45	}56	}
57
58	pub fn try_sup_this(&self) -> Result<SupThis> {
59		self.0
60			.sup_this
61			.clone()
62			.ok_or_else(|| CantUseSelfSupOutsideOfObject.into())
63	}
4664
47	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {65	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {
48		use std::cmp::Ordering;66		use std::cmp::Ordering;
83	pub fn with_var(self, name: impl Into<IStr>, value: Val) -> Self {101	pub fn with_var(self, name: impl Into<IStr>, value: Val) -> Self {
84		let mut new_bindings = FxHashMap::with_capacity(1);102		let mut new_bindings = FxHashMap::with_capacity(1);
85		new_bindings.insert(name.into(), Thunk::evaluated(value));103		new_bindings.insert(name.into(), Thunk::evaluated(value));
86		self.extend(new_bindings, None, None, None)104		self.extend_bindings(new_bindings)
87	}105	}
88106
89	#[must_use]107	#[must_use]
90	pub fn extend(108	pub fn extend_bindings_sup_this(
91		self,109		self,
92		new_bindings: FxHashMap<IStr, Thunk<Val>>,110		new_bindings: FxHashMap<IStr, Thunk<Val>>,
93		new_dollar: Option<ObjValue>,111		sup_this: SupThis,
94		new_sup: Option<ObjValue>,
95		new_this: Option<ObjValue>,
96	) -> Self {112	) -> Self {
97		let ctx = &self.0;113		let ctx = &self;
98		let dollar = new_dollar.or_else(|| ctx.dollar.clone());114		let dollar = ctx
99		let this = new_this.or_else(|| ctx.this.clone());115			.0
100		let sup = new_sup.or_else(|| ctx.sup.clone());116			.dollar
117			.clone()
118			.or_else(|| Some(sup_this.this().clone()));
101		let bindings = if new_bindings.is_empty() {119		let bindings = if new_bindings.is_empty() {
102			ctx.bindings.clone()120			ctx.0.bindings.clone()
103		} else {121		} else {
104			ctx.bindings.clone().extend(new_bindings)122			ctx.0.bindings.clone().extend(new_bindings)
105		};123		};
106		Self(Cc::new(ContextInternals {124		Self(Cc::new(ContextInternal {
107			dollar,125			dollar,
108			sup,126			sup_this: Some(sup_this),
109			this,
110			bindings,127			bindings,
111		}))128		}))
112	}129	}
130	#[must_use]
131	pub fn extend_bindings(self, new_bindings: FxHashMap<IStr, Thunk<Val>>) -> Self {
132		if new_bindings.is_empty() {
133			return self;
134		}
135		let ctx = &self;
136		let bindings = if new_bindings.is_empty() {
137			ctx.0.bindings.clone()
138		} else {
139			ctx.0.bindings.clone().extend(new_bindings)
140		};
141		Self(Cc::new(ContextInternal {
142			dollar: ctx.0.dollar.clone(),
143			sup_this: ctx.0.sup_this.clone(),
144			bindings,
145		}))
146	}
113}147}
114148
115impl PartialEq for Context {149#[derive(Default)]
116	fn eq(&self, other: &Self) -> bool {
117		Cc::ptr_eq(&self.0, &other.0)
118	}
119}
120
121pub struct ContextBuilder {150pub struct ContextBuilder {
122	bindings: FxHashMap<IStr, Thunk<Val>>,151	bindings: FxHashMap<IStr, Thunk<Val>>,
141	}172	}
173
142	/// # Panics174	/// # Panics
175	///
143	/// If `name` is already bound176	/// If `name` is already bound. Makes no sense to bind same local multiple times,
177	/// unless it is separate context layers.
144	pub fn bind(&mut self, name: impl Into<IStr>, value: Thunk<Val>) -> &mut Self {178	pub fn bind(&mut self, name: impl Into<IStr>, value: Thunk<Val>) -> &mut Self {
145		let old = self.bindings.insert(name.into(), value);179		let old = self.bindings.insert(name.into(), value);
146		assert!(old.is_none(), "variable bound twice in single context call");180		assert!(old.is_none(), "variable bound twice in single context call");
147		self181		self
148	}182	}
149	pub fn build(self) -> Context {183	pub fn build(self) -> Context {
150		if let Some(parent) = self.extend {184		if let Some(parent) = self.extend {
151			// TODO: replace self.extend with Result<Context, State>, and remove `state` field
152			parent.extend(self.bindings, None, None, None)185			parent.extend_bindings(self.bindings)
153		} else {186		} else {
154			Context(Cc::new(ContextInternals {187			Context(Cc::new(ContextInternal {
155				bindings: LayeredHashMap::new(self.bindings),188				bindings: LayeredHashMap::new(self.bindings),
156				dollar: None,189				dollar: None,
157				sup: None,190				sup_this: None,
158				this: None,
159			}))191			}))
160		}192		}
161	}193	}

1use std::ptr::addr_of;
1use std::cell::OnceCell;2use std::{cell::OnceCell, hash::Hasher};
23
4use educe::Educe;
3use jrsonnet_gcmodule::{Cc, Trace};5use jrsonnet_gcmodule::{Cc, Trace};
46
5use crate::{bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue, Result};7use crate::{bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue, Result};
68
7// TODO: Replace with OnceCell once in std
8#[derive(Clone, Trace)]9#[derive(Trace, Educe)]
10#[educe(Clone)]
9pub struct Pending<V: Trace + 'static>(pub Cc<OnceCell<V>>);11pub struct Pending<V: Trace + 'static>(pub Cc<OnceCell<V>>);
10impl<T: Trace + 'static> Pending<T> {12impl<T: Trace + 'static> Pending<T> {
11	pub fn new() -> Self {13	pub fn new() -> Self {
25			.expect("wrapper is filled already");27			.expect("wrapper is filled already");
26	}28	}
27}29}
28impl<T: Clone + Trace + 'static> Pending<T> {30impl<T: Trace + 'static + Clone> Pending<T> {
29	/// # Panics31	/// # Panics
30	/// If wrapper is not yet filled32	/// If wrapper is not yet filled
31	pub fn unwrap(&self) -> T {33	pub fn unwrap(&self) -> T {
53	}55	}
54}56}
57
58pub fn identity_hash<T, H: Hasher>(v: &Cc<T>, hasher: &mut H) {
59	hasher.write_usize(addr_of!(**v) as usize);
60}
5561

119	#[error("binary operation {1} {0} {2} is not implemented")]119	#[error("binary operation {1} {0} {2} is not implemented")]
120	BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),120	BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),
121121
122	#[error("no top level object in this context")]
123	NoTopLevelObjectFound,
124	#[error("self is only usable inside objects")]122	#[error("self/super/$ are only usable inside objects")]
125	CantUseSelfOutsideOfObject,123	CantUseSelfSupOutsideOfObject,
126	#[error("no super found")]124	#[error("no super found")]
127	NoSuperFound,125	NoSuperFound,
128126

1111
12use self::destructure::destruct;12use self::destructure::destruct;
13use crate::{13use crate::{
14	arr::ArrValue,14	Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, ResultExt, SupThis, Unbound, Val, arr::ArrValue, bail, destructure::evaluate_dest, error::{ErrorKind::*, suggest_object_fields}, evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op}, function::{CallLocation, FuncDesc, FuncVal}, gc::WithCapacityExt as _, in_frame, typed::Typed, val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk}, with_state
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	Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, ResultExt,
25	Unbound, Val,
26};15};
27pub mod destructure;16pub mod destructure;
28pub mod operator;17pub mod operator;
126					let fctx = Pending::new();115					let fctx = Pending::new();
127					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());116					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());
128					destruct(var, item, fctx.clone(), &mut new_bindings)?;117					destruct(var, item, fctx.clone(), &mut new_bindings)?;
129					let ctx = ctx118					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
130						.clone()
131						.extend(new_bindings, None, None, None)
132						.into_future(fctx);
133119
134					evaluate_comp(ctx, &specs[1..], callback)?;120					evaluate_comp(ctx, &specs[1..], callback)?;
169impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}155impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}
170156
171fn evaluate_object_locals(157fn evaluate_object_locals(
172	fctx: Pending<Context>,158	fctx: Context,
173	locals: Rc<Vec<BindSpec>>,159	locals: Rc<Vec<BindSpec>>,
174) -> impl CloneableUnbound<Context> {160) -> impl CloneableUnbound<Context> {
175	#[derive(Trace, Clone)]161	#[derive(Trace, Clone)]
176	struct UnboundLocals {162	struct UnboundLocals {
177		fctx: Pending<Context>,163		fctx: Context,
178		locals: Rc<Vec<BindSpec>>,164		locals: Rc<Vec<BindSpec>>,
179	}165	}
180	impl Unbound for UnboundLocals {166	impl Unbound for UnboundLocals {
181		type Bound = Context;167		type Bound = Context;
182168
183		fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Context> {169		fn bind(&self, sup_this: SupThis) -> Result<Context> {
184			let fctx = Context::new_future();170			let fctx = Context::new_future();
185			let mut new_bindings =171			let mut new_bindings =
186				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());172				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());
187			for b in self.locals.iter() {173			for b in self.locals.iter() {
188				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;174				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
189			}175			}
190176
191			let ctx = self.fctx.unwrap();177			let ctx = self.fctx.clone();
192			let new_dollar = ctx.dollar().cloned().or_else(|| this.clone());
193178
194			let ctx = ctx179			let ctx = ctx
195				.extend(new_bindings, new_dollar, sup, this)180				.extend_bindings_sup_this(new_bindings, sup_this)
196				.into_future(fctx);181				.into_future(fctx);
197182
198			Ok(ctx)183			Ok(ctx)
229			}214			}
230			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {215			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
231				type Bound = Val;216				type Bound = Val;
232				fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {217				fn bind(&self, sup_this: SupThis) -> Result<Val> {
233					evaluate_named(self.uctx.bind(sup, this)?, &self.value, self.name.clone())218					evaluate_named(self.uctx.bind(sup_this)?, &self.value, self.name.clone())
234				}219				}
235			}220			}
236221
260			}245			}
261			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {246			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {
262				type Bound = Val;247				type Bound = Val;
263				fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {248				fn bind(&self, sup_this: SupThis) -> Result<Val> {
264					Ok(evaluate_method(249					Ok(evaluate_method(
265						self.uctx.bind(sup, this)?,250						self.uctx.bind(sup_this)?,
266						self.name.clone(),251						self.name.clone(),
267						self.params.clone(),252						self.params.clone(),
268						self.value.clone(),253						self.value.clone(),
298			.collect::<Vec<_>>(),283			.collect::<Vec<_>>(),
299	);284	);
300
301	let fctx = Context::new_future();
302285
303	// We have single context for all fields, so we can cache binds286	// We have single context for all fields, so we can cache binds
304	let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));287	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));
305288
306	for member in members {289	for member in members {
307		match member {290		match member {
315					assert: AssertStmt,298					assert: AssertStmt,
316				}299				}
317				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {300				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {
318					fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {301					fn run(&self, sup_this: SupThis) -> Result<()> {
319						let ctx = self.uctx.bind(sup, this)?;302						let ctx = self.uctx.bind(sup_this)?;
320						evaluate_assert(ctx, &self.assert)303						evaluate_assert(ctx, &self.assert)
321					}304					}
322				}305				}
330			}313			}
331		}314		}
332	}315	}
333	let this = builder.build();316	Ok(builder.build())
334	fctx.fill(ctx.extend(FxHashMap::new(), None, None, Some(this.clone())));
335	Ok(this)
336}317}
337318
338pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {319pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {
347					.cloned()328					.cloned()
348					.collect::<Vec<_>>(),329					.collect::<Vec<_>>(),
349			);330			);
350			let mut ctxs = vec![];
351			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {331			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {
352				let fctx = Context::new_future();332				let uctx = evaluate_object_locals(ctx.clone(), locals.clone());
353				ctxs.push((ctx.clone(), fctx.clone()));
354				let uctx = evaluate_object_locals(fctx, locals.clone());
355333
356				evaluate_field_member(&mut builder, ctx, uctx, &obj.field)334				evaluate_field_member(&mut builder, ctx, uctx, &obj.field)
357			})?;335			})?;
358336
359			let this = builder.build();337			builder.build()
360			for (ctx, fctx) in ctxs {
361				let _ctx = ctx
362					.extend(FxHashMap::new(), None, None, Some(this.clone()))
363					.into_future(fctx);
364			}
365			this
366		}338		}
367	})339	})
368}340}
428	}400	}
429	let loc = expr.span();401	let loc = expr.span();
430	Ok(match expr.expr() {402	Ok(match expr.expr() {
431		Literal(LiteralType::This) => {403		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),
432			Val::Obj(ctx.this().ok_or(CantUseSelfOutsideOfObject)?.clone())
433		}
434		Literal(LiteralType::Super) => Val::Obj(404		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),
435			ctx.super_obj().ok_or(NoSuperFound)?.with_this(
436				ctx.this()
437					.expect("if super exists - then this should too")
438					.clone(),
439			),
440		),
441		Literal(LiteralType::Dollar) => {405		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),
442			Val::Obj(ctx.dollar().ok_or(NoTopLevelObjectFound)?.clone())
443		}
444		Literal(LiteralType::True) => Val::Bool(true),406		Literal(LiteralType::True) => Val::Bool(true),
445		Literal(LiteralType::False) => Val::Bool(false),407		Literal(LiteralType::False) => Val::Bool(false),
446		Literal(LiteralType::Null) => Val::Null,408		Literal(LiteralType::Null) => Val::Null,
452		//414		//
453		// Note that other jsonnet implementations will fail on `if value in (super)` expression,415		// Note that other jsonnet implementations will fail on `if value in (super)` expression,
454		// because the standalone super literal is not supported, that is because in other416		// because the standalone super literal is not supported, that is because in other
455		// implementations `in super` treated differently from in `smth_else`.417		// implementations `in super` treated differently from `in smth_else`.
456		BinaryOp(field, BinaryOpType::In, e)418		BinaryOp(field, BinaryOpType::In, e)
457			if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>419			if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>
458		{420		{
459			let Some(super_obj) = ctx.super_obj() else {421			let sup_this = ctx.try_sup_this()?;
422			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.
423			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.
424			if !sup_this.has_super() {
460				return Ok(Val::Bool(false));425				return Ok(Val::Bool(false));
461			};426			}
462			let field = evaluate(ctx.clone(), field)?;427			let field = evaluate(ctx, field)?;
463			Val::Bool(super_obj.has_field_ex(field.to_string()?, true))428			Val::Bool(sup_this.field_in_super(field.to_string()?))
464		}429		}
465		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,430		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,
466		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,431		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
473			let mut parts = parts.iter();438			let mut parts = parts.iter();
474			let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {439			let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {
475				let part = parts.next().expect("at least part should exist");440				let part = parts.next().expect("at least part should exist");
441				// sup_this existence check might also be skipped here for null-coalesce...
442				// But I believe this might cause errors.
476				let Some(super_obj) = ctx.super_obj() else {443				let sup_this = ctx.try_sup_this()?;
444				if !sup_this.has_super() {
477					#[cfg(feature = "exp-null-coaelse")]445					#[cfg(feature = "exp-null-coaelse")]
478					if part.null_coaelse {446					if part.null_coaelse {
479						return Ok(Val::Null);447						return Ok(Val::Null);
480					}448					}
481					bail!(NoSuperFound)449					bail!(NoSuperFound)
482				};450				}
483				let name = evaluate(ctx.clone(), &part.value)?;451				let name = evaluate(ctx.clone(), &part.value)?;
484452
485				let Val::Str(name) = name else {453				let Val::Str(name) = name else {
490					))458					))
491				};459				};
492460
493				let this = ctx
494					.this()
495					.expect("no this found, while super present, should not happen");
496				let name = name.into_flat();461				let name = name.into_flat();
497				match super_obj462				match sup_this
498					.get_for(name.clone(), this.clone())463					.get_super(name.clone())
499					.with_description_src(&part.value, || format!("field <{name}> access"))?464					.with_description_src(&part.value, || format!("field <{name}> access"))?
500				{465				{
501					Some(v) => v,466					Some(v) => v,
502					#[cfg(feature = "exp-null-coaelse")]467					#[cfg(feature = "exp-null-coaelse")]
503					None if part.null_coaelse => return Ok(Val::Null),468					None if part.null_coaelse => return Ok(Val::Null),
504					None => {469					None => {
505						let suggestions = suggest_object_fields(super_obj, name.clone());470						let suggestions = suggest_object_fields(
471							&sup_this.standalone_super().expect("super exists"),
472							name.clone(),
473						);
506474
507						bail!(NoSuchField(name, suggestions))475						bail!(NoSuchField(name, suggestions))
589			for b in bindings {557			for b in bindings {
590				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;558				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
591			}559			}
592			let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);560			let ctx = ctx.extend_bindings(new_bindings).into_future(fctx);
593			evaluate(ctx, &returned.clone())?561			evaluate(ctx, &returned.clone())?
594		}562		}
595		Arr(items) => {563		Arr(items) => {
652		Slice(value, desc) => {620		Slice(value, desc) => {
653			fn parse_idx<T: Typed>(621			fn parse_idx<T: Typed>(
654				loc: CallLocation<'_>,622				loc: CallLocation<'_>,
655				ctx: &Context,623				ctx: Context,
656				expr: Option<&LocExpr>,624				expr: Option<&LocExpr>,
657				desc: &'static str,625				desc: &'static str,
658			) -> Result<Option<T>> {626			) -> Result<Option<T>> {
659				if let Some(value) = expr {627				if let Some(value) = expr {
660					Ok(in_frame(628					Ok(in_frame(
661						loc,629						loc,
662						|| format!("slice {desc}"),630						|| format!("slice {desc}"),
663						|| <Option<T>>::from_untyped(evaluate(ctx.clone(), value)?),631						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),
664					)?)632					)?)
665				} else {633				} else {
666					Ok(None)634					Ok(None)
670			let indexable = evaluate(ctx.clone(), value)?;638			let indexable = evaluate(ctx.clone(), value)?;
671			let loc = CallLocation::new(&loc);639			let loc = CallLocation::new(&loc);
672640
673			let start = parse_idx(loc, &ctx, desc.start.as_ref(), "start")?;641			let start = parse_idx(loc, ctx.clone(), desc.start.as_ref(), "start")?;
674			let end = parse_idx(loc, &ctx, desc.end.as_ref(), "end")?;642			let end = parse_idx(loc, ctx.clone(), desc.end.as_ref(), "end")?;
675			let step = parse_idx(loc, &ctx, desc.step.as_ref(), "step")?;643			let step = parse_idx(loc, ctx, desc.step.as_ref(), "step")?;
676644
677			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?645			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?
678		}646		}
681				bail!("computed imports are not supported")649				bail!("computed imports are not supported")
682			};650			};
683			let tmp = loc.clone().0;651			let tmp = loc.clone().0;
684			let s = ctx.state();652			with_state(|s| {
685			let resolved_path = s.resolve_from(tmp.source_path(), path)?;653				let resolved_path = s.resolve_from(tmp.source_path(), path)?;
686			match i {654				Ok(match i {
687				Import(_) => in_frame(655					Import(_) => in_frame(
688					CallLocation::new(&loc),656						CallLocation::new(&loc),
689					|| format!("import {:?}", path.clone()),657						|| format!("import {:?}", path.clone()),
690					|| s.import_resolved(resolved_path),658						|| s.import_resolved(resolved_path),
691				)?,659					)?,
692				ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),660					ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),
693				ImportBin(_) => Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?)),661					ImportBin(_) => {
662						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))
663					}
694				_ => unreachable!(),664					_ => unreachable!(),
695			}665				}) as Result<Val>
666			})?
696		}667		}
697	})668	})
698}669}