git.delta.rocks / jrsonnet / refs/commits / 4c3faa0f088c

117	ctx: *mut c_void,117	ctx: *mut c_void,
118) {118) {
119	vm.state119	vm.state.set_import_resolver(CallbackImportResolver {
120		.set_import_resolver(Box::new(CallbackImportResolver {
121			cb,120		cb,
122			ctx,121		ctx,
123			out: RefCell::new(HashMap::new()),122		out: RefCell::new(HashMap::new()),
124		}))123	})
125}124}
126125
127/// # Safety126/// # Safety

7use jrsonnet_evaluator::{7use jrsonnet_evaluator::{
8	error::{Error, ErrorKind},8	error::{Error, ErrorKind},
9	function::builtin::{NativeCallback, NativeCallbackHandler},9	function::builtin::{NativeCallback, NativeCallbackHandler},
10	tb,
11	typed::Typed,10	typed::Typed,
12	IStr, Val,11	IStr, Val,
13};12};
14use jrsonnet_gcmodule::Cc;
1513
16use crate::VM;14use crate::VM;
1715
102		.add_native(100		.add_native(
103			name,101			name,
104			#[allow(deprecated)]102			#[allow(deprecated)]
105			Cc::new(tb!(NativeCallback::new(103			NativeCallback::new(params, JsonnetNativeCallbackHandler { ctx, cb }),
106				params,
107				tb!(JsonnetNativeCallbackHandler { ctx, cb }),
108			))),
109		)104		)
110}105}
111106

13#[no_mangle]13#[no_mangle]
14pub extern "C" fn jsonnet_json_extract_string(_vm: &VM, v: &Val) -> *mut c_char {14pub extern "C" fn jsonnet_json_extract_string(_vm: &VM, v: &Val) -> *mut c_char {
15	match v {15	match v {
16		Val::Str(s) => CString::new(s as &str).unwrap().into_raw(),16		Val::Str(s) => {
17			let s = s.clone().into_flat();
18			CString::new(s.as_str()).unwrap().into_raw()
19		}
17		_ => std::ptr::null_mut(),20		_ => std::ptr::null_mut(),
18	}21	}
19}22}

6};6};
77
8use jrsonnet_evaluator::{val::ArrValue, ObjValue, Val};8use jrsonnet_evaluator::{
9use jrsonnet_gcmodule::Cc;9	val::{ArrValue, StrValue},
10	ObjValue, Val,
11};
1012
11use crate::VM;13use crate::VM;
19pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {21pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {
20	let val = CStr::from_ptr(val);22	let val = CStr::from_ptr(val);
21	let val = val.to_str().expect("string is not utf-8");23	let val = val.to_str().expect("string is not utf-8");
22	Box::into_raw(Box::new(Val::Str(val.into())))24	Box::into_raw(Box::new(Val::Str(StrValue::Flat(val.into()))))
23}25}
2426
25/// Convert the given double to a `JsonnetJsonValue`.27/// Convert the given double to a `JsonnetJsonValue`.
46/// Assign elements with [`jsonnet_json_array_append`].48/// Assign elements with [`jsonnet_json_array_append`].
47#[no_mangle]49#[no_mangle]
48pub extern "C" fn jsonnet_json_make_array(_vm: &VM) -> *mut Val {50pub extern "C" fn jsonnet_json_make_array(_vm: &VM) -> *mut Val {
49	Box::into_raw(Box::new(Val::Arr(ArrValue::eager(Cc::new(Vec::new())))))51	Box::into_raw(Box::new(Val::Arr(ArrValue::eager(Vec::new()))))
50}52}
5153
52/// Make a `JsonnetJsonValue` representing an object.54/// Make a `JsonnetJsonValue` representing an object.

54			library_paths.extend(env::split_paths(path.as_os_str()));54			library_paths.extend(env::split_paths(path.as_os_str()));
55		}55		}
5656
57		s.set_import_resolver(Box::new(FileImportResolver::new(library_paths)));57		s.set_import_resolver(FileImportResolver::new(library_paths));
5858
59		set_stack_depth_limit(self.max_stack);59		set_stack_depth_limit(self.max_stack);
60		Ok(())60		Ok(())

55		Self::Lazy(LazyArray(thunks))55		Self::Lazy(LazyArray(thunks))
56	}56	}
5757
58	pub fn eager(values: Cc<Vec<Val>>) -> Self {58	pub fn eager(values: Vec<Val>) -> Self {
59		Self::Eager(EagerArray(values))59		Self::Eager(EagerArray(Cc::new(values)))
60	}60	}
6161
62	pub fn repeated(data: ArrValue, repeats: usize) -> Option<Self> {62	pub fn repeated(data: ArrValue, repeats: usize) -> Option<Self> {
81				out.push(i);81				out.push(i);
82			};82			};
83		}83		}
84		Ok(Self::eager(Cc::new(out)))84		Ok(Self::eager(out))
85	}85	}
8686
87	pub fn extended(a: ArrValue, b: ArrValue) -> Self {87	pub fn extended(a: ArrValue, b: ArrValue) -> Self {
98			let mut out = Vec::with_capacity(a.len() + b.len());98			let mut out = Vec::with_capacity(a.len() + b.len());
99			out.extend(a);99			out.extend(a);
100			out.extend(b);100			out.extend(b);
101			Self::eager(Cc::new(out))101			Self::eager(out)
102		} else {102		} else {
103			let mut out = Vec::with_capacity(a.len() + b.len());103			let mut out = Vec::with_capacity(a.len() + b.len());
104			out.extend(a.iter_lazy());104			out.extend(a.iter_lazy());
235}235}
236impl From<Vec<Val>> for ArrValue {236impl From<Vec<Val>> for ArrValue {
237	fn from(value: Vec<Val>) -> Self {237	fn from(value: Vec<Val>) -> Self {
238		Self::eager(Cc::new(value))238		Self::eager(value)
239	}239	}
240}240}
241impl From<Vec<Thunk<Val>>> for ArrValue {241impl From<Vec<Thunk<Val>>> for ArrValue {
242	fn from(value: Vec<Thunk<Val>>) -> Self {242	fn from(value: Vec<Thunk<Val>>) -> Self {
243		Self::lazy(Cc::new(value))243		Self::lazy(Cc::new(value))
244	}244	}
245}245}
246impl FromIterator<Val> for ArrValue {
247	fn from_iter<T: IntoIterator<Item = Val>>(iter: T) -> Self {
248		Self::eager(iter.into_iter().collect())
249	}
250}
246251
247#[cfg(target_pointer_width = "64")]252#[cfg(target_pointer_width = "64")]
248static_assertions::assert_eq_size!(ArrValue, [u8; 16]);253static_assertions::assert_eq_size!(ArrValue, [u8; 16]);

7use jrsonnet_interner::IBytes;7use jrsonnet_interner::IBytes;
8use jrsonnet_parser::LocExpr;8use jrsonnet_parser::LocExpr;
99
10use super::{ArrValue, ArrayLikeIter};10use super::ArrValue;
11use crate::{11use crate::{
12	error::ErrorKind::InfiniteRecursionDetected, evaluate, function::FuncVal, tb, typed::Any,12	error::ErrorKind::InfiniteRecursionDetected, evaluate, function::FuncVal, val::ThunkValue,
13	val::ThunkValue, Context, Error, Result, Thunk, Val,13	Context, Error, Result, Thunk, Val,
14};14};
1515
75	}75	}
7676
77	#[cfg(not(feature = "nightly"))]77	#[cfg(not(feature = "nightly"))]
78	fn iter_cheap(&self) -> Option<impl ArrayLikeIter<Val> + '_> {78	fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {
79		Some(79		Some(
80			self.inner80			self.inner
81				.iter_cheap()?81				.iter_cheap()?
300			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}300			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}
301		};301		};
302302
303		Some(Thunk::new(tb!(ArrayElement {303		Some(Thunk::new(ArrayElement {
304			arr_thunk: self.clone(),304			arr_thunk: self.clone(),
305			index,305			index,
306		})))306		}))
307	}307	}
308	fn get_cheap(&self, _index: usize) -> Option<Val> {308	fn get_cheap(&self, _index: usize) -> Option<Val> {
309		None309		None
748			.get(index)748			.get(index)
749			.transpose()749			.transpose()
750			.expect("index checked")750			.expect("index checked")
751			.and_then(|r| self.0.mapper.evaluate_simple(&(Any(r),)));751			.and_then(|r| self.0.mapper.evaluate_simple(&(r,)));
752752
753		let new_value = match val {753		let new_value = match val {
754			Ok(v) => v,754			Ok(v) => v,
787			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}787			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}
788		};788		};
789789
790		Some(Thunk::new(tb!(ArrayElement {790		Some(Thunk::new(ArrayElement {
791			arr_thunk: self.clone(),791			arr_thunk: self.clone(),
792			index,792			index,
793		})))793		}))
794	}794	}
795795
796	fn get_cheap(&self, _index: usize) -> Option<Val> {796	fn get_cheap(&self, _index: usize) -> Option<Val> {

294		path: handler.resolve(path.as_ref()).await?,294		path: handler.resolve(path.as_ref()).await?,
295		parse: true,295		parse: true,
296	}];296	}];
297	// let mut resolved = HashMap::<(SourcePath, IStr), (SourcePath, bool)>::new();
298	while let Some(job) = queue.pop() {297	while let Some(job) = queue.pop() {
299		match job {298		match job {
300			Job::LoadFile { path, parse } => {299			Job::LoadFile { path, parse } => {
349			}348			}
350		}349		}
351	}350	}
352	s.set_import_resolver(Box::new(ResolvedImportResolver {351	s.set_import_resolver(ResolvedImportResolver {
353		resolved: RefCell::new(resolved),352		resolved: RefCell::new(resolved),
354	}));353	});
355	Ok(())354	Ok(())
356}355}
357356

39			.expect("used state from dummy context")39			.expect("used state from dummy context")
40	}40	}
4141
42	pub fn dollar(&self) -> &Option<ObjValue> {42	pub fn dollar(&self) -> Option<&ObjValue> {
43		&self.0.dollar43		self.0.dollar.as_ref()
44	}44	}
4545
46	pub fn this(&self) -> &Option<ObjValue> {46	pub fn this(&self) -> Option<&ObjValue> {
47		&self.0.this47		self.0.this.as_ref()
48	}48	}
4949
50	pub fn super_obj(&self) -> &Option<ObjValue> {50	pub fn super_obj(&self) -> Option<&ObjValue> {
51		&self.0.sup51		self.0.sup.as_ref()
52	}52	}
5353
54	#[cfg(not(feature = "friendly-errors"))]54	#[cfg(not(feature = "friendly-errors"))]
131	}131	}
132}132}
133
134// impl Default for Context {
135// 	fn default() -> Self {
136// 		Self::new()
137// 	}
138// }
139133
140impl PartialEq for Context {134impl PartialEq for Context {
141	fn eq(&self, other: &Self) -> bool {135	fn eq(&self, other: &Self) -> bool {

6	error::{ErrorKind::*, Result},6	error::{ErrorKind::*, Result},
7	evaluate, evaluate_method, evaluate_named,7	evaluate, evaluate_method, evaluate_named,
8	gc::GcHashMap,8	gc::GcHashMap,
9	tb, throw,9	throw,
10	val::ThunkValue,10	val::ThunkValue,
11	Context, Pending, Thunk, Val,11	Context, Pending, Thunk, Val,
12};12};
63				}63				}
64			}64			}
6565
66			let full = Thunk::new(tb!(DataThunk {66			let full = Thunk::new(DataThunk {
67				min_len: start.len() + end.len(),67				min_len: start.len() + end.len(),
68				has_rest: rest.is_some(),68				has_rest: rest.is_some(),
69				parent,69				parent,
70			}));70			});
7171
72			{72			{
73				#[derive(Trace)]73				#[derive(Trace)]
86				for (i, d) in start.iter().enumerate() {86				for (i, d) in start.iter().enumerate() {
87					destruct(87					destruct(
88						d,88						d,
89						Thunk::new(tb!(BaseThunk {89						Thunk::new(BaseThunk {
90							full: full.clone(),90							full: full.clone(),
91							index: i,91							index: i,
92						})),92						}),
93						fctx.clone(),93						fctx.clone(),
94						new_bindings,94						new_bindings,
95					)?;95					)?;
119119
120					destruct(120					destruct(
121						&Destruct::Full(v.clone()),121						&Destruct::Full(v.clone()),
122						Thunk::new(tb!(RestThunk {122						Thunk::new(RestThunk {
123							full: full.clone(),123							full: full.clone(),
124							start: start.len(),124							start: start.len(),
125							end: end.len(),125							end: end.len(),
126						})),126						}),
127						fctx.clone(),127						fctx.clone(),
128						new_bindings,128						new_bindings,
129					)?;129					)?;
151				for (i, d) in end.iter().enumerate() {151				for (i, d) in end.iter().enumerate() {
152					destruct(152					destruct(
153						d,153						d,
154						Thunk::new(tb!(EndThunk {154						Thunk::new(EndThunk {
155							full: full.clone(),155							full: full.clone(),
156							index: i,156							index: i,
157							end: end.len(),157							end: end.len(),
158						})),158						}),
159						fctx.clone(),159						fctx.clone(),
160						new_bindings,160						new_bindings,
161					)?;161					)?;
199				.filter(|f| f.2.is_none())199				.filter(|f| f.2.is_none())
200				.map(|f| f.0.clone())200				.map(|f| f.0.clone())
201				.collect();201				.collect();
202			let full = Thunk::new(tb!(DataThunk {202			let full = Thunk::new(DataThunk {
203				parent,203				parent,
204				field_names,204				field_names,
205				has_rest: rest.is_some()205				has_rest: rest.is_some(),
206			}));206			});
207207
208			for (field, d, default) in fields {208			for (field, d, default) in fields {
209				#[derive(Trace)]209				#[derive(Trace)]
225						}225						}
226					}226					}
227				}227				}
228				let value = Thunk::new(tb!(FieldThunk {228				let value = Thunk::new(FieldThunk {
229					full: full.clone(),229					full: full.clone(),
230					field: field.clone(),230					field: field.clone(),
231					default: default.clone().map(|e| (fctx.clone(), e)),231					default: default.clone().map(|e| (fctx.clone(), e)),
232				}));232				});
233				if let Some(d) = d {233				if let Some(d) = d {
234					destruct(d, value, fctx.clone(), new_bindings)?;234					destruct(d, value, fctx.clone(), new_bindings)?;
235				} else {235				} else {
268					)268					)
269				}269				}
270			}270			}
271			let data = Thunk::new(tb!(EvaluateThunkValue {271			let data = Thunk::new(EvaluateThunkValue {
272				name: into.name(),272				name: into.name(),
273				fctx: fctx.clone(),273				fctx: fctx.clone(),
274				expr: value.clone(),274				expr: value.clone(),
275			}));275			});
276			destruct(into, data, fctx, new_bindings)?;276			destruct(into, data, fctx, new_bindings)?;
277		}277		}
278		BindSpec::Function {278		BindSpec::Function {
302302
303			let old = new_bindings.insert(303			let old = new_bindings.insert(
304				name.clone(),304				name.clone(),
305				Thunk::new(tb!(MethodThunk {305				Thunk::new(MethodThunk {
306					fctx,306					fctx,
307					name: name.clone(),307					name: name.clone(),
308					params: params.clone(),308					params: params.clone(),
309					value: value.clone()309					value: value.clone(),
310				})),310				}),
311			);311			);
312			if old.is_some() {312			if old.is_some() {
313				throw!(DuplicateLocalVar(name.clone()))313				throw!(DuplicateLocalVar(name.clone()))

15	error::ErrorKind::*,15	error::ErrorKind::*,
16	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},16	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},
17	function::{CallLocation, FuncDesc, FuncVal},17	function::{CallLocation, FuncDesc, FuncVal},
18	tb, throw,18	throw,
19	typed::Typed,19	typed::Typed,
20	val::{CachedUnbound, IndexableVal, StrValue, Thunk, ThunkValue},20	val::{CachedUnbound, IndexableVal, StrValue, Thunk, ThunkValue},
21	Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, State,21	Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, State,
45			if n.iter().any(|e| !is_trivial(e)) {45			if n.iter().any(|e| !is_trivial(e)) {
46				return None;46				return None;
47			}47			}
48			Val::Arr(ArrValue::eager(Cc::new(48			Val::Arr(ArrValue::eager(
49				n.iter()49				n.iter()
50					.map(evaluate_trivial)50					.map(evaluate_trivial)
51					.map(|e| e.expect("checked trivial"))51					.map(|e| e.expect("checked trivial"))
52					.collect(),52					.collect(),
53			)))53			))
54		}54		}
55		Expr::Parened(e) => evaluate_trivial(e)?,55		Expr::Parened(e) => evaluate_trivial(e)?,
56		_ => return None,56		_ => return None,
136					let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());136					let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());
137					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(Cc::new(vec![137					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(Cc::new(vec![
138						Thunk::evaluated(Val::Str(StrValue::Flat(field.clone()))),138						Thunk::evaluated(Val::Str(StrValue::Flat(field.clone()))),
139						Thunk::new(tb!(ObjectFieldThunk {139						Thunk::new(ObjectFieldThunk {
140							field: field.clone(),140							field: field.clone(),
141							obj: obj.clone(),141							obj: obj.clone(),
142						})),142						}),
143					]))));143					]))));
144					destruct(var, value, fctx.clone(), &mut new_bindings)?;144					destruct(var, value, fctx.clone(), &mut new_bindings)?;
145					let ctx = ctx145					let ctx = ctx
180			}180			}
181181
182			let ctx = self.fctx.unwrap();182			let ctx = self.fctx.unwrap();
183			let new_dollar = ctx.dollar().clone().or_else(|| this.clone());183			let new_dollar = ctx.dollar().cloned().or_else(|| this.clone());
184184
185			let ctx = ctx185			let ctx = ctx
186				.extend(new_bindings, new_dollar, sup, this)186				.extend(new_bindings, new_dollar, sup, this)
230				.with_add(*plus)230				.with_add(*plus)
231				.with_visibility(*visibility)231				.with_visibility(*visibility)
232				.with_location(value.1.clone())232				.with_location(value.1.clone())
233				.bindable(tb!(UnboundValue {233				.bindable(UnboundValue {
234					uctx,234					uctx,
235					value: value.clone(),235					value: value.clone(),
236					name,236					name,
237				}))?;237				})?;
238		}238		}
239		FieldMember {239		FieldMember {
240			params: Some(params),240			params: Some(params),
265				.member(name.clone())265				.member(name.clone())
266				.with_visibility(*visibility)266				.with_visibility(*visibility)
267				.with_location(value.1.clone())267				.with_location(value.1.clone())
268				.bindable(tb!(UnboundMethod {268				.bindable(UnboundMethod {
269					uctx,269					uctx,
270					value: value.clone(),270					value: value.clone(),
271					params: params.clone(),271					params: params.clone(),
272					name,272					name,
273				}))?;273				})?;
274		}274		}
275	}275	}
276	Ok(())276	Ok(())
311						evaluate_assert(ctx, &self.assert)311						evaluate_assert(ctx, &self.assert)
312					}312					}
313				}313				}
314				builder.assert(tb!(ObjectAssert {314				builder.assert(ObjectAssert {
315					uctx: uctx.clone(),315					uctx: uctx.clone(),
316					assert: stmt.clone(),316					assert: stmt.clone(),
317				}));317				});
318			}318			}
319			Member::BindStmt(_) => {319			Member::BindStmt(_) => {
320				// Already handled320				// Already handled
420	let LocExpr(expr, loc) = expr;420	let LocExpr(expr, loc) = expr;
421	Ok(match &**expr {421	Ok(match &**expr {
422		Literal(LiteralType::This) => {422		Literal(LiteralType::This) => {
423			Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)423			Val::Obj(ctx.this().ok_or(CantUseSelfOutsideOfObject)?.clone())
424		}424		}
425		Literal(LiteralType::Super) => Val::Obj(425		Literal(LiteralType::Super) => Val::Obj(
426			ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(426			ctx.super_obj().ok_or(NoSuperFound)?.with_this(
427				ctx.this()427				ctx.this()
428					.clone()428					.expect("if super exists - then this should too")
429					.expect("if super exists - then this should too"),429					.clone(),
430			),430			),
431		),431		),
432		Literal(LiteralType::Dollar) => {432		Literal(LiteralType::Dollar) => {
433			Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)433			Val::Obj(ctx.dollar().ok_or(NoTopLevelObjectFound)?.clone())
434		}434		}
435		Literal(LiteralType::True) => Val::Bool(true),435		Literal(LiteralType::True) => Val::Bool(true),
436		Literal(LiteralType::False) => Val::Bool(false),436		Literal(LiteralType::False) => Val::Bool(false),
455				))455				))
456			};456			};
457			ctx.super_obj()457			ctx.super_obj()
458				.clone()
459				.expect("no super found")458				.expect("no super found")
460				.get_for(name.into_flat(), ctx.this().clone().expect("no this found"))?459				.get_for(name.into_flat(), ctx.this().expect("no this found").clone())?
461				.expect("value not found")460				.expect("value not found")
462		}461		}
463		Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {462		Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {
563						evaluate(self.ctx, &self.item)562						evaluate(self.ctx, &self.item)
564					}563					}
565				}564				}
566				Val::Arr(ArrValue::lazy(Cc::new(vec![Thunk::new(tb!(565				Val::Arr(ArrValue::lazy(Cc::new(vec![Thunk::new(ArrayElement {
567					ArrayElement {
568						ctx,566					ctx,
569						item: items[0].clone(),567					item: items[0].clone(),
570					}568				})])))
571				))])))
572			} else {569			} else {
573				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))570				Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))
574			}571			}
579				out.push(evaluate(ctx, expr)?);576				out.push(evaluate(ctx, expr)?);
580				Ok(())577				Ok(())
581			})?;578			})?;
582			Val::Arr(ArrValue::eager(Cc::new(out)))579			Val::Arr(ArrValue::eager(out))
583		}580		}
584		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),581		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),
585		ObjExtend(a, b) => evaluate_add_op(582		ObjExtend(a, b) => evaluate_add_op(
623			fn parse_idx<T: Typed>(620			fn parse_idx<T: Typed>(
624				loc: CallLocation<'_>,621				loc: CallLocation<'_>,
625				ctx: &Context,622				ctx: &Context,
626				expr: &Option<LocExpr>,623				expr: Option<&LocExpr>,
627				desc: &'static str,624				desc: &'static str,
628			) -> Result<Option<T>> {625			) -> Result<Option<T>> {
629				if let Some(value) = expr {626				if let Some(value) = expr {
640			let indexable = evaluate(ctx.clone(), value)?;637			let indexable = evaluate(ctx.clone(), value)?;
641			let loc = CallLocation::new(loc);638			let loc = CallLocation::new(loc);
642639
643			let start = parse_idx(loc, &ctx, &desc.start, "start")?;640			let start = parse_idx(loc, &ctx, desc.start.as_ref(), "start")?;
644			let end = parse_idx(loc, &ctx, &desc.end, "end")?;641			let end = parse_idx(loc, &ctx, desc.end.as_ref(), "end")?;
645			let step = parse_idx(loc, &ctx, &desc.step, "step")?;642			let step = parse_idx(loc, &ctx, desc.step.as_ref(), "step")?;
646643
647			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?644			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?
648		}645		}

7	error::Result,7	error::Result,
8	evaluate,8	evaluate,
9	gc::GcHashMap,9	gc::GcHashMap,
10	tb,
11	typed::Typed,10	typed::Typed,
12	val::{StrValue, ThunkValue},11	val::{StrValue, ThunkValue},
13	Context, Thunk, Val,12	Context, Thunk, Val,
37		Ok(if tailstrict {36		Ok(if tailstrict {
38			Thunk::evaluated(evaluate(ctx, self)?)37			Thunk::evaluated(evaluate(ctx, self)?)
39		} else {38		} else {
40			Thunk::new(tb!(EvaluateThunk {39			Thunk::new(EvaluateThunk {
41				ctx,40				ctx,
42				expr: (*self).clone(),41				expr: (*self).clone(),
43			}))42			})
44		})43		})
45	}44	}
46}45}
69			TlaArg::Code(code) => Ok(if tailstrict {68			TlaArg::Code(code) => Ok(if tailstrict {
70				Thunk::evaluated(evaluate(ctx, code)?)69				Thunk::evaluated(evaluate(ctx, code)?)
71			} else {70			} else {
72				Thunk::new(tb!(EvaluateThunk {71				Thunk::new(EvaluateThunk {
73					ctx,72					ctx,
74					expr: code.clone(),73					expr: code.clone(),
75				}))74				})
76			}),75			}),
77			TlaArg::Val(val) => Ok(Thunk::evaluated(val.clone())),76			TlaArg::Val(val) => Ok(Thunk::evaluated(val.clone())),
78		}77		}
128	}127	}
129	fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}128	fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}
130}129}
131impl OptionalContext for Vec<Val> {}
132130
133impl ArgsLike for ArgsDesc {131impl ArgsLike for ArgsDesc {
134	fn unnamed_len(&self) -> usize {132	fn unnamed_len(&self) -> usize {
147				if tailstrict {145				if tailstrict {
148					Thunk::evaluated(evaluate(ctx.clone(), arg)?)146					Thunk::evaluated(evaluate(ctx.clone(), arg)?)
149				} else {147				} else {
150					Thunk::new(tb!(EvaluateThunk {148					Thunk::new(EvaluateThunk {
151						ctx: ctx.clone(),149						ctx: ctx.clone(),
152						expr: arg.clone(),150						expr: arg.clone(),
153					}))151					})
154				},152				},
155			)?;153			)?;
156		}154		}
169				if tailstrict {167				if tailstrict {
170					Thunk::evaluated(evaluate(ctx.clone(), arg)?)168					Thunk::evaluated(evaluate(ctx.clone(), arg)?)
171				} else {169				} else {
172					Thunk::new(tb!(EvaluateThunk {170					Thunk::new(EvaluateThunk {
173						ctx: ctx.clone(),171						ctx: ctx.clone(),
174						expr: arg.clone(),172						expr: arg.clone(),
175					}))173					})
176				},174				},
177			)?;175			)?;
178		}176		}