git.delta.rocks / jrsonnet / refs/commits / 9411dba19aab

717name = "jrsonnet-parser"717name = "jrsonnet-parser"
718version = "0.5.0-pre97"718version = "0.5.0-pre97"
719dependencies = [719dependencies = [
720 "insta",
720 "jrsonnet-gcmodule",721 "jrsonnet-gcmodule",
721 "jrsonnet-interner",722 "jrsonnet-interner",
722 "peg",723 "peg",

1use std::{1use std::{
2	any::Any,2	any::Any,
3	fmt::{self},3	fmt::{self},
4	num::NonZeroU32,4	num::NonZeroU32, rc::Rc,
5};5};
66
7use jrsonnet_gcmodule::{cc_dyn, Cc};7use jrsonnet_gcmodule::{cc_dyn, Cc};
8use jrsonnet_interner::IBytes;8use jrsonnet_interner::IBytes;
9use jrsonnet_parser::LocExpr;9use jrsonnet_parser::{Expr, Spanned};
1010
11use crate::{function::FuncVal, Context, Result, Thunk, Val};11use crate::{function::FuncVal, Context, Result, Thunk, Val};
1212
37		Self::new(RangeArray::empty())37		Self::new(RangeArray::empty())
38	}38	}
3939
40	pub fn expr(ctx: Context, exprs: impl IntoIterator<Item = LocExpr>) -> Self {40	pub fn expr(ctx: Context, exprs: Rc<Vec<Spanned<Expr>>>) -> Self {
41		Self::new(ExprArray::new(ctx, exprs))41		Self::new(ExprArray::new(ctx, exprs))
42	}42	}
4343

1use std::rc::Rc;
1use std::{any::Any, cell::RefCell, fmt::Debug, iter, mem::replace};2use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace};
23
3use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_gcmodule::{Cc, Trace};
4use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_interner::{IBytes, IStr};
5use jrsonnet_parser::LocExpr;6use jrsonnet_parser::{Expr, Spanned};
67
7use super::ArrValue;8use super::ArrValue;
8use crate::{9use crate::{
103}104}
104105
105#[derive(Debug, Trace, Clone)]106#[derive(Debug, Trace, Clone)]
106enum ArrayThunk<T: 'static + Trace> {107enum ArrayThunk {
107	Computed(Val),108	Computed(Val),
108	Errored(Error),109	Errored(Error),
109	Waiting(T),110	Waiting,
110	Pending,111	Pending,
111}112}
112113
113#[derive(Debug, Trace, Clone)]114#[derive(Debug, Trace, Clone)]
114pub struct ExprArray {115pub struct ExprArray {
115	ctx: Context,116	ctx: Context,
117	src: Rc<Vec<Spanned<Expr>>>,
116	cached: Cc<RefCell<Vec<ArrayThunk<LocExpr>>>>,118	cached: Cc<RefCell<Vec<ArrayThunk>>>,
117}119}
118impl ExprArray {120impl ExprArray {
119	pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {121	pub fn new(ctx: Context, src: Rc<Vec<Spanned<Expr>>>) -> Self {
120		Self {122		Self {
121			ctx,123			ctx,
122			cached: Cc::new(RefCell::new(124			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),
123				items.into_iter().map(ArrayThunk::Waiting).collect(),125			src,
124			)),
125		}126		}
126	}127	}
137			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),138			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),
138			ArrayThunk::Errored(e) => return Err(e.clone()),139			ArrayThunk::Errored(e) => return Err(e.clone()),
139			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),140			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),
140			ArrayThunk::Waiting(..) => {}141			ArrayThunk::Waiting => {}
141		};142		};
142143
143		let ArrayThunk::Waiting(expr) =144		let ArrayThunk::Waiting =
144			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)145			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
145		else {146		else {
146			unreachable!()147			unreachable!()
147		};148		};
148149
149		let new_value = match evaluate(self.ctx.clone(), &expr) {150		let new_value = match evaluate(self.ctx.clone(), &self.src[index]) {
150			Ok(v) => v,151			Ok(v) => v,
151			Err(e) => {152			Err(e) => {
152				self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());153				self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());
163		match &self.cached.borrow()[index] {164		match &self.cached.borrow()[index] {
164			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),165			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
165			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),166			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
166			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}167			ArrayThunk::Waiting | ArrayThunk::Pending => {}
167		};168		};
168169
169		#[derive(Trace)]170		#[derive(Trace)]
406#[derive(Trace, Debug, Clone)]407#[derive(Trace, Debug, Clone)]
407pub struct MappedArray<const WITH_INDEX: bool> {408pub struct MappedArray<const WITH_INDEX: bool> {
408	inner: ArrValue,409	inner: ArrValue,
409	cached: Cc<RefCell<Vec<ArrayThunk<()>>>>,410	cached: Cc<RefCell<Vec<ArrayThunk>>>,
410	mapper: FuncVal,411	mapper: FuncVal,
411}412}
412impl<const WITH_INDEX: bool> MappedArray<WITH_INDEX> {413impl<const WITH_INDEX: bool> MappedArray<WITH_INDEX> {
413	pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {414	pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {
414		let len = inner.len();415		let len = inner.len();
415		Self {416		Self {
416			inner,417			inner,
417			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting(()); len])),418			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; len])),
418			mapper,419			mapper,
419		}420		}
420	}421	}
439			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),440			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),
440			ArrayThunk::Errored(e) => return Err(e.clone()),441			ArrayThunk::Errored(e) => return Err(e.clone()),
441			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),442			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),
442			ArrayThunk::Waiting(..) => {}443			ArrayThunk::Waiting => {}
443		};444		};
444445
445		let ArrayThunk::Waiting(()) =446		let ArrayThunk::Waiting =
446			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)447			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
447		else {448		else {
448			unreachable!()449			unreachable!()
472		match &self.cached.borrow()[index] {473		match &self.cached.borrow()[index] {
473			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),474			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
474			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),475			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
475			ArrayThunk::Waiting(()) | ArrayThunk::Pending => {}476			ArrayThunk::Waiting | ArrayThunk::Pending => {}
476		};477		};
477478
478		#[derive(Trace)]479		#[derive(Trace)]

1use std::rc::Rc;
1use std::{any::Any, cell::RefCell, future::Future};2use std::{any::Any, cell::RefCell, future::Future};
23
3use jrsonnet_gcmodule::Acyclic;4use jrsonnet_gcmodule::Acyclic;
4use jrsonnet_parser::{5use jrsonnet_parser::{
5	ArgsDesc, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName, ForSpecData,6	ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName,
6	IfSpecData, LocExpr, Member, ObjBody, Param, ParamsDesc, ParserSettings, SliceDesc, Source,7	ForSpecData, IfElse, IfSpecData, ImportKind, Member, ObjBody, Param, ParamsDesc,
7	SourcePath,8	ParserSettings, Slice, SliceDesc, Source, SourcePath, Spanned,
8};9};
9use rustc_hash::FxHashMap;10use rustc_hash::FxHashMap;
1011
1920
20// Visits all nodes, trying to find import statements21// Visits all nodes, trying to find import statements
21#[allow(clippy::too_many_lines)]22#[allow(clippy::too_many_lines)]
22pub fn find_imports(expr: &LocExpr, out: &mut FoundImports) {23pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {
23	fn in_destruct(dest: &Destruct, #[allow(unused_variables)] out: &mut FoundImports) {24	fn in_destruct(dest: &Destruct, #[allow(unused_variables)] out: &mut FoundImports) {
24		match dest {25		match dest {
25			#[cfg(feature = "exp-destruct")]26			#[cfg(feature = "exp-destruct")]
120							find_imports(value, out);121							find_imports(value, out);
121						}122						}
122						Member::BindStmt(_) => todo!(),123						Member::BindStmt(_) => todo!(),
123						Member::AssertStmt(AssertStmt(expr, expr2)) => {124						Member::AssertStmt(assert) => {
124							find_imports(expr, out);125							find_imports(&assert.0, out);
125							if let Some(expr) = expr2 {126							if let Some(expr) = &assert.1 {
126								find_imports(expr, out);127								find_imports(expr, out);
127							}128							}
128						}129						}
132			ObjBody::ObjComp(_) => todo!(),133			ObjBody::ObjComp(_) => todo!(),
133		}134		}
134	}135	}
135	match &*expr.expr() {136	match &**expr {
136		Expr::Import(v) | Expr::ImportStr(v) | Expr::ImportBin(v) => {137		Expr::Import(_, v) => {
137			if let Expr::Str(s) = &*v.expr() {138			if let Expr::Str(s) = &***v {
138				out.0.push(Import {139				out.0.push(Import {
139					path: ResolvePathOwned::Str(s.to_string()),140					path: ResolvePathOwned::Str(s.to_string()),
140					expression: matches!(&*expr.expr(), Expr::Import(_)),141					expression: matches!(&**expr, Expr::Import(ImportKind::Normal, _)),
141				});142				});
142			}143			}
143			// Non-string import will fail in runtime144			// Non-string import will fail in runtime
146		Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}147		Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}
147148
148		Expr::Arr(arr) => {149		Expr::Arr(arr) => {
149			for expr in arr {150			for expr in &**arr {
150				find_imports(expr, out);151				find_imports(expr, out);
151			}152			}
152		}153		}
159			find_imports(expr, out);160			find_imports(expr, out);
160			in_obj(obj, out);161			in_obj(obj, out);
161		}162		}
162		Expr::BinaryOp(a, _, b) => {163		Expr::BinaryOp(binop) => {
163			find_imports(a, out);164			find_imports(&binop.lhs, out);
164			find_imports(b, out);165			find_imports(&binop.rhs, out);
165		}166		}
166		Expr::AssertExpr(AssertStmt(expr, expr2), then) => {167		Expr::AssertExpr(assert) => {
168			let AssertExpr {
169				assert: AssertStmt(expr, expr2),
170				rest,
171			} = &**assert;
167			find_imports(expr, out);172			find_imports(expr, out);
168			if let Some(expr) = expr2 {173			if let Some(expr) = expr2 {
169				find_imports(expr, out);174				find_imports(expr, out);
170			}175			}
171			find_imports(then, out);176			find_imports(rest, out);
172		}177		}
173		Expr::LocalExpr(specs, expr) => {178		Expr::LocalExpr(specs, expr) => {
174			in_bind(specs, out);179			in_bind(specs, out);
175			find_imports(expr, out);180			find_imports(expr, out);
188			in_params(params, out);193			in_params(params, out);
189			find_imports(expr, out);194			find_imports(expr, out);
190		}195		}
191		Expr::IfElse {196		Expr::IfElse(if_else) => {
197			let IfElse {
192			cond: IfSpecData(expr),198				cond: IfSpecData(expr),
193			cond_then,199				cond_then,
194			cond_else,200				cond_else,
195		} => {201			} = &**if_else;
196			find_imports(expr, out);202			find_imports(expr, out);
197			find_imports(cond_then, out);203			find_imports(cond_then, out);
198			if let Some(expr) = cond_else {204			if let Some(expr) = cond_else {
199				find_imports(expr, out);205				find_imports(expr, out);
200			}206			}
201		}207		}
202		Expr::Slice(expr, SliceDesc { start, end, step }) => {208		Expr::Slice(slice) => {
209			let Slice {
210				value,
211				slice: SliceDesc { start, end, step },
212			} = &**slice;
203			find_imports(expr, out);213			find_imports(value, out);
204			if let Some(expr) = start {214			if let Some(expr) = start {
205				find_imports(expr, out);215				find_imports(expr, out);
206			}216			}
210			if let Some(expr) = step {220			if let Some(expr) = step {
211				find_imports(expr, out);221				find_imports(expr, out);
212			}222			}
213		}223		}
214		Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {224		Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {
215			find_imports(expr, out);225			find_imports(expr, out);
216		}226		}
315						let source = Source::new(path.clone(), code.clone());325						let source = Source::new(path.clone(), code.clone());
316						// If failed - then skip import326						// If failed - then skip import
317						file.parsed =327						file.parsed = jrsonnet_parser::parse(&code, &ParserSettings { source })
328							.map(Rc::new)
318							jrsonnet_parser::parse(&code, &ParserSettings { source }).ok();329							.ok();
319						if let Some(parsed) = &file.parsed {330						if let Some(parsed) = &file.parsed {
320							let mut imports = FoundImports(vec![]);331							let mut imports = FoundImports(vec![]);

4	fmt::{Debug, Display},4	fmt::{Debug, Display},
5};5};
66
7use jrsonnet_gcmodule::Trace;7use jrsonnet_gcmodule::{Acyclic, Trace};
8use jrsonnet_interner::IStr;8use jrsonnet_interner::IStr;
9use jrsonnet_parser::{BinaryOpType, LocExpr, Source, SourcePath, Span, UnaryOpType};9use jrsonnet_parser::{BinaryOpType, Source, SourcePath, Span, Spanned, UnaryOpType};
10use jrsonnet_types::ValType;10use jrsonnet_types::ValType;
11use thiserror::Error;11use thiserror::Error;
1212
324pub trait ErrorSource {324pub trait ErrorSource {
325	fn to_location(self) -> Option<Span>;325	fn to_location(self) -> Option<Span>;
326}326}
327impl ErrorSource for &LocExpr {327impl<T: Acyclic> ErrorSource for &Spanned<T> {
328	fn to_location(self) -> Option<Span> {328	fn to_location(self) -> Option<Span> {
329		Some(self.span())329		Some(self.span())
330	}330	}

4use jrsonnet_interner::IStr;4use jrsonnet_interner::IStr;
5use jrsonnet_parser::{5use jrsonnet_parser::{
6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,
7	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,7	ForSpecData, IfSpecData, ImportKind, LiteralType, Member, ObjBody, ParamsDesc, Spanned,
8};8};
9use jrsonnet_types::ValType;9use jrsonnet_types::ValType;
10use rustc_hash::FxHashMap;10use rustc_hash::FxHashMap;
46	stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)46	stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)
47}47}
4848
49pub fn evaluate_trivial(expr: &LocExpr) -> Option<Val> {49pub fn evaluate_trivial(expr: &Spanned<Expr>) -> Option<Val> {
50	fn is_trivial(expr: &LocExpr) -> bool {50	fn is_trivial(expr: &Spanned<Expr>) -> bool {
51		match expr.expr() {51		match &**expr {
52			Expr::Str(_)52			Expr::Str(_)
53			| Expr::Num(_)53			| Expr::Num(_)
54			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,54			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,
55			Expr::Arr(a) => a.iter().all(is_trivial),55			Expr::Arr(a) => a.iter().all(is_trivial),
56			_ => false,56			_ => false,
57		}57		}
58	}58	}
59	Some(match expr.expr() {59	Some(match &**expr {
60		Expr::Str(s) => Val::string(s.clone()),60		Expr::Str(s) => Val::string(s.clone()),
61		Expr::Num(n) => {61		Expr::Num(n) => {
62			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))62			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))
79	})79	})
80}80}
8181
82pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {82pub fn evaluate_method(
83	ctx: Context,
84	name: IStr,
85	params: ParamsDesc,
86	body: Rc<Spanned<Expr>>,
87) -> Val {
83	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {88	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
84		name,89		name,
215			#[derive(Trace)]220			#[derive(Trace)]
216			struct UnboundValue<B: Trace> {221			struct UnboundValue<B: Trace> {
217				uctx: B,222				uctx: B,
218				value: LocExpr,223				value: Rc<Spanned<Expr>>,
219				name: IStr,224				name: IStr,
220			}225			}
221			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {226			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
245			#[derive(Trace)]250			#[derive(Trace)]
246			struct UnboundMethod<B: Trace> {251			struct UnboundMethod<B: Trace> {
247				uctx: B,252				uctx: B,
248				value: LocExpr,253				value: Rc<Spanned<Expr>>,
249				params: ParamsDesc,254				params: ParamsDesc,
250				name: IStr,255				name: IStr,
251			}256			}
301				#[derive(Trace)]306				#[derive(Trace)]
302				struct ObjectAssert<B: Trace> {307				struct ObjectAssert<B: Trace> {
303					uctx: B,308					uctx: B,
304					assert: AssertStmt,309					assert: Rc<AssertStmt>,
305				}310				}
306				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {311				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {
307					fn run(&self, sup_this: SupThis) -> Result<()> {312					fn run(&self, sup_this: SupThis) -> Result<()> {
347352
348pub fn evaluate_apply(353pub fn evaluate_apply(
349	ctx: Context,354	ctx: Context,
350	value: &LocExpr,355	value: &Spanned<Expr>,
351	args: &ArgsDesc,356	args: &ArgsDesc,
352	loc: CallLocation<'_>,357	loc: CallLocation<'_>,
353	tailstrict: bool,358	tailstrict: bool,
389	Ok(())394	Ok(())
390}395}
391396
392pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {397pub fn evaluate_named(ctx: Context, expr: &Spanned<Expr>, name: IStr) -> Result<Val> {
393	use Expr::*;398	use Expr::*;
394	Ok(match expr.expr() {399	Ok(match &**expr {
395		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),400		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
396		_ => evaluate(ctx, expr)?,401		_ => evaluate(ctx, expr)?,
397	})402	})
398}403}
399404
400#[allow(clippy::too_many_lines)]405#[allow(clippy::too_many_lines)]
401pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {406pub fn evaluate(ctx: Context, expr: &Spanned<Expr>) -> Result<Val> {
402	use Expr::*;407	use Expr::*;
403408
404	if let Some(trivial) = evaluate_trivial(expr) {409	if let Some(trivial) = evaluate_trivial(expr) {
405		return Ok(trivial);410		return Ok(trivial);
406	}411	}
407	let loc = expr.span();412	let loc = expr.span();
408	Ok(match expr.expr() {413	Ok(match &**expr {
409		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),414		Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),
410		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),415		Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),
411		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),416		Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),
420		// Note that other jsonnet implementations will fail on `if value in (super)` expression,425		// Note that other jsonnet implementations will fail on `if value in (super)` expression,
421		// because the standalone super literal is not supported, that is because in other426		// because the standalone super literal is not supported, that is because in other
422		// implementations `in super` treated differently from `in smth_else`.427		// implementations `in super` treated differently from `in smth_else`.
423		BinaryOp(field, BinaryOpType::In, e)428		BinaryOp(bin)
424			if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>429			if matches!(&*bin.rhs, Expr::Literal(LiteralType::Super))
430				&& bin.op == BinaryOpType::In =>
425		{431		{
426			let sup_this = ctx.try_sup_this()?;432			let sup_this = ctx.try_sup_this()?;
427			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.433			// In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.
428			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.434			// In jrsonnet, however, this wasn't true, this was kept here for compatibility.
429			if !sup_this.has_super() {435			if !sup_this.has_super() {
430				return Ok(Val::Bool(false));436				return Ok(Val::Bool(false));
431			}437			}
432			let field = evaluate(ctx, field)?;438			let field = evaluate(ctx, &bin.lhs)?;
433			Val::Bool(sup_this.field_in_super(field.to_string()?))439			Val::Bool(sup_this.field_in_super(field.to_string()?))
434		}440		}
435		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,441		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,
436		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,442		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
437		Var(name) => in_frame(443		Var(name) => in_frame(
438			CallLocation::new(&loc),444			CallLocation::new(&loc),
441		)?,447		)?,
442		Index { indexable, parts } => ensure_sufficient_stack(|| {448		Index { indexable, parts } => ensure_sufficient_stack(|| {
443			let mut parts = parts.iter();449			let mut parts = parts.iter();
444			let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {450			let mut indexable = if matches!(&***indexable, Expr::Literal(LiteralType::Super)) {
445				let part = parts.next().expect("at least part should exist");451				let part = parts.next().expect("at least part should exist");
446				// sup_this existence check might also be skipped here for null-coalesce...452				// sup_this existence check might also be skipped here for null-coalesce...
447				// But I believe this might cause errors.453				// But I believe this might cause errors.
574		Arr(items) => {580		Arr(items) => {
575			if items.is_empty() {581			if items.is_empty() {
576				Val::Arr(ArrValue::empty())582				Val::Arr(ArrValue::empty())
577			} else if items.len() == 1 {583			} else {
578				let item = items[0].clone();
579				Val::Arr(ArrValue::lazy(vec![Thunk!(move || evaluate(ctx, &item))]))
580			} else {
581				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))584				Val::Arr(ArrValue::expr(ctx, items.clone()))
582			}585			}
583		}586		}
584		ArrComp(expr, comp_specs) => {587		ArrComp(expr, comp_specs) => {
601		Function(params, body) => {604		Function(params, body) => {
602			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())605			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())
603		}606		}
604		AssertExpr(assert, returned) => {607		AssertExpr(assert) => {
605			evaluate_assert(ctx.clone(), assert)?;608			evaluate_assert(ctx.clone(), &assert.assert)?;
606			evaluate(ctx, returned)?609			evaluate(ctx, &assert.rest)?
607		}610		}
608		ErrorStmt(e) => in_frame(611		ErrorStmt(e) => in_frame(
609			CallLocation::new(&loc),612			CallLocation::new(&loc),
610			|| "error statement".to_owned(),613			|| "error statement".to_owned(),
611			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),614			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
612		)?,615		)?,
613		IfElse {616		IfElse (if_else)
614			cond,617		// {
615			cond_then,618		// 	cond,
616			cond_else,619		// 	cond_then,
620		// 	cond_else,
621		// }
617		} => {622		=> {
618			if in_frame(623			if in_frame(
619				CallLocation::new(&loc),624				CallLocation::new(&loc),
620				|| "if condition".to_owned(),625				|| "if condition".to_owned(),
621				|| bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),626				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?),
622			)? {627			)? {
623				evaluate(ctx, cond_then)?628				evaluate(ctx, &if_else.cond_then)?
624			} else {629			} else {
625				match cond_else {630				match &if_else.cond_else {
626					Some(v) => evaluate(ctx, v)?,631					Some(v) => evaluate(ctx, v)?,
627					None => Val::Null,632					None => Val::Null,
628				}633				}
629			}634			}
630		}635		}
631		Slice(value, desc) => {636		Slice(slice) => {
632			fn parse_idx<T: Typed>(637			fn parse_idx<T: Typed>(
633				loc: CallLocation<'_>,638				loc: CallLocation<'_>,
634				ctx: Context,639				ctx: Context,
635				expr: Option<&LocExpr>,640				expr: Option<&Spanned<Expr>>,
636				desc: &'static str,641				desc: &'static str,
637			) -> Result<Option<T>> {642			) -> Result<Option<T>> {
638				if let Some(value) = expr {643				if let Some(value) = expr {
646				}651				}
647			}652			}
648653
649			let indexable = evaluate(ctx.clone(), value)?;654			let indexable = evaluate(ctx.clone(), &slice.value)?;
650			let loc = CallLocation::new(&loc);655			let loc = CallLocation::new(&loc);
651656
652			let start = parse_idx(loc, ctx.clone(), desc.start.as_ref(), "start")?;657			let start = parse_idx(loc, ctx.clone(), slice.slice.start.as_ref(), "start")?;
653			let end = parse_idx(loc, ctx.clone(), desc.end.as_ref(), "end")?;658			let end = parse_idx(loc, ctx.clone(), slice.slice.end.as_ref(), "end")?;
654			let step = parse_idx(loc, ctx, desc.step.as_ref(), "step")?;659			let step = parse_idx(loc, ctx, slice.slice.step.as_ref(), "step")?;
655660
656			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?661			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?
657		}662		}
658		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {663		Import(kind, path) => {
659			let Expr::Str(path) = &path.expr() else {664			let Expr::Str(path) = &***path else {
660				bail!("computed imports are not supported")665				bail!("computed imports are not supported")
661			};666			};
662			let tmp = loc.clone().0;667			let tmp = loc.clone().0;
663			with_state(|s| {668			with_state(|s| {
664				let resolved_path = s.resolve_from(tmp.source_path(), path)?;669				let resolved_path = s.resolve_from(tmp.source_path(), path)?;
665				Ok(match i {670				Ok(match kind {
666					Import(_) => in_frame(671					ImportKind::Normal => in_frame(
667						CallLocation::new(&loc),672						CallLocation::new(&loc),
668						|| format!("import {:?}", path.clone()),673						|| format!("import {:?}", path.clone()),
669						|| s.import_resolved(resolved_path),674						|| s.import_resolved(resolved_path),
670					)?,675					)?,
671					ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),676					ImportKind::Str => Val::string(s.import_resolved_str(resolved_path)?),
672					ImportBin(_) => {677					ImportKind::Bin => {
673						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))678						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))
674					}679					}
675					_ => unreachable!(),
676				}) as Result<Val>680				}) as Result<Val>
677			})?681			})?
678		}682		}