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

99
10use crate::{Context, Result, Thunk, Val, analyze::LExpr, function::NativeFn, typed::IntoUntyped};10use crate::{
11	Context, Result, Thunk, Val,
12	analyze::{ClosureShape, LExpr},
13	function::NativeFn,
14	typed::IntoUntyped,
15};
1116
12mod spec;17mod spec;
36		Self::new(())41		Self::new(())
37	}42	}
3843
39	pub fn expr(ctx: Context, exprs: Rc<Vec<LExpr>>) -> Self {44	pub fn expr(ctx: Context, shape: &ClosureShape, exprs: Rc<Vec<LExpr>>) -> Self {
40		Self::new(ExprArray::new(ctx, exprs))45		Self::new(ExprArray::new(ctx, shape, exprs))
41	}46	}
4247
43	pub fn repeated(data: Self, repeats: u32) -> Option<Self> {48	pub fn repeated(data: Self, repeats: u32) -> Option<Self> {

12use super::ArrValue;12use super::ArrValue;
13use crate::{13use crate::{
14	Context, Error, ObjValue, Result, Thunk, Val,14	Context, Error, ObjValue, Result, Thunk, Val,
15	analyze::LExpr,15	analyze::{ClosureShape, LExpr},
16	error::ErrorKind::InfiniteRecursionDetected,16	error::ErrorKind::InfiniteRecursionDetected,
17	evaluate::evaluate,17	evaluate::evaluate,
18	function::NativeFn,18	function::NativeFn,
123	cached: Cc<RefCell<Vec<ArrayThunk>>>,123	cached: Cc<RefCell<Vec<ArrayThunk>>>,
124}124}
125impl ExprArray {125impl ExprArray {
126	pub fn new(ctx: Context, src: Rc<Vec<LExpr>>) -> Self {126	pub fn new(outer: Context, shape: &ClosureShape, src: Rc<Vec<LExpr>>) -> Self {
127		Self {127		Self {
128			ctx,128			ctx: Context::enter_using(&outer, shape),
129			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),129			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),
130			src,130			src,
131		}131		}

4use jrsonnet_ir::{IStr, Source, SourcePath, visit::Visitor};4use jrsonnet_ir::{IStr, Source, SourcePath, visit::Visitor};
5use rustc_hash::FxHashMap;5use rustc_hash::FxHashMap;
66
7use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};7use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, Result, State};
88
9pub struct Import {9pub struct Import {
10	path: ResolvePathOwned,10	path: ResolvePathOwned,
109				}109				}
110			}110			}
111			Job::ParseFile(path) => {111			Job::ParseFile(path) => {
112				if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {112				if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path)
113					if file.parsed.is_none() {113					&& file.parsed.is_none()
114				{
114						let Some(code) = file.get_string() else {115					let Some(code) = file.get_string() else {
115							continue;116						continue;
128							}129						}
129						}130					}
130					}131				}
131				}
132			}132			}
133			Job::ResolveImport { from, import } => {133			Job::ResolveImport { from, import } => {
134				{134				{

1use std::{clone::Clone, fmt::Debug};1use std::{
2	cell::{Cell, OnceCell, RefCell},
3	clone::Clone,
4	fmt::{self, Debug},
5};
26
3use educe::Educe;7use educe::Educe;
4use jrsonnet_gcmodule::{Cc, Trace};8use jrsonnet_gcmodule::{Cc, Trace};
5use jrsonnet_interner::IStr;9use jrsonnet_interner::IStr;
610
7use crate::{Pending, Result, SupThis, Thunk, Val, analyze::LocalId, error, error::ErrorKind::*};11use crate::{
12	Result, SupThis, Thunk, Val,
13	analyze::{CaptureSlot, ClosureShape, LSlot, LocalId, LocalSlot},
14	bail, error,
15	error::ErrorKind::*,
16};
817
9#[derive(Debug, Trace, Clone, Educe)]18#[derive(Debug, Trace, Clone, Educe)]
10#[educe(PartialEq)]19#[educe(PartialEq)]
11pub struct Context(#[educe(PartialEq(method = Cc::ptr_eq))] Cc<ContextInternal>);20pub struct Context(#[educe(PartialEq(method = Cc::ptr_eq))] pub(crate) Cc<ContextInternal>);
1221
13#[derive(Debug, Trace, Clone)]22#[derive(Trace)]
14struct ContextInternal {23pub(crate) struct ContextInternal {
15	sup_this: Option<SupThis>,24	/// Immutable, packed at closure-create time.
16	/// `bindings[i]` corresponds to `LocalId(offset + i)`.
17	bindings: Vec<Option<Thunk<Val>>>,25	pub(crate) captures: Cc<Vec<Thunk<Val>>>,
18	offset: u32,26	/// Filled during closure initialization
27	pub(crate) locals: Cc<LocalsFrame>,
19	parent: Option<Context>,28	pub(crate) sup_this: Option<SupThis>,
20}29}
2130
22impl Context {31impl Debug for ContextInternal {
23	pub fn new_future() -> Pending<Self> {32	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24		Pending::new()33		f.debug_struct("ContextInternal")
34			.field("captures", &self.captures.len())
35			.field("locals", &self.locals)
36			.field("sup_this", &self.sup_this.is_some())
37			.finish()
25	}38	}
39}
2640
41#[derive(Trace, Debug)]
42pub(crate) struct IterFrame {
27	pub fn sup_this(&self) -> Option<&SupThis> {43	slots: Vec<RefCell<Option<Thunk<Val>>>>,
44	captured: Cell<bool>,
45}
46impl IterFrame {
47	pub fn new(n: u16) -> IterFrame {
28		self.0.sup_this.as_ref()48		let cells: Vec<RefCell<Option<Thunk<Val>>>> = (0..n).map(|_| RefCell::new(None)).collect();
49		IterFrame {
50			slots: cells,
51			captured: Cell::new(false),
52		}
29	}53	}
30
31	pub fn try_sup_this(&self) -> Result<SupThis> {54	pub fn set(&self, slot: LocalSlot, value: Thunk<Val>) {
32		self.055		*self.slots[slot.0 as usize].borrow_mut() = Some(value);
33			.sup_this
34			.clone()
35			.ok_or_else(|| error!(CantUseSelfSupOutsideOfObject))
36	}56	}
57}
3758
59#[derive(Trace, Debug)]
60pub(crate) enum LocalsFrame {
38	/// Update binding in `CoW` fashion. Only useful for eager comprehension61	Once1(OnceCell<Thunk<Val>>),
62	/// Letrec/function/object/for frames - slots are filled during frame setup
39	/// fast-path, as it requires Cc refcount to be 1; Use `ContextBuilder` otherwise.63	Once(Vec<OnceCell<Thunk<Val>>>),
64	/// Comp-eager fast-path, cells are reset per iteration for the unique frames (i.e for the non-capturing thunks)
40	pub(crate) fn cow_fill_binding(&mut self, id: LocalId, value: Thunk<Val>) {65	Iter(IterFrame),
66}
67impl LocalsFrame {
68	pub fn set(&self, slot: LocalSlot, value: Thunk<Val>) {
41		let mut value = Some(Some(value));69		match self {
42
43		self.0.update_with(|inner| {70			LocalsFrame::Once1(cell) => {
44			let local_idx = (id.0 - inner.offset) as usize;71				debug_assert_eq!(slot.0, 0, "Once1 only holds slot 0");
45			while inner.bindings.len() <= local_idx {72				cell.set(value)
73					.map_err(|_| ())
46				inner.bindings.push(None);74					.expect("slot already filled");
47			}75			}
48			inner.bindings[local_idx] = value.take().expect("called once");76			LocalsFrame::Once(cells) => {
77				cells[slot.0 as usize]
78					.set(value)
79					.map_err(|_| ())
80					.expect("slot already filled");
49		});81			}
82			LocalsFrame::Iter(_) => unreachable!("iter frame has different constructors"),
83		}
50	}84	}
85}
5186
87impl LocalsFrame {
52	pub fn binding(&self, id: LocalId) -> Option<Thunk<Val>> {88	pub(crate) fn new_once(n: u16) -> Cc<Self> {
53		let id_num = id.0;89		if n == 1 {
54		if id_num >= self.0.offset {
55			let local_idx = (id_num - self.0.offset) as usize;
56			if let Some(Some(thunk)) = self.0.bindings.get(local_idx) {
57				return Some(thunk.clone());90			return Cc::new(Self::Once1(OnceCell::new()));
58			}
59		}91		}
60		if let Some(parent) = &self.0.parent {92		let cells: Vec<OnceCell<Thunk<Val>>> = (0..n).map(|_| OnceCell::new()).collect();
61			return parent.binding(id);
62		}93		Cc::new(Self::Once(cells))
63		None
64	}94	}
95}
6596
97pub(crate) struct IterContext {
66	#[must_use]98	context: Context,
99}
100impl IterContext {
67	pub fn into_future(self, ctx: Pending<Self>) -> Self {101	pub(crate) fn create(&self, build: impl FnOnce(&IterFrame)) -> Result<Context> {
68		{102		if !Cc::is_unique(&self.context.0.locals) {
69			ctx.clone().fill(self);103			bail!(EagerCompspecCaptured);
70		}104		}
71		ctx.unwrap()105		let LocalsFrame::Iter(frame) = &*self.context.0.locals else {
106			unreachable!("IterContext is only created for Iter ctx");
107		};
108		if frame.captured.get() {
109			bail!(EagerCompspecCaptured);
110		}
111		build(frame);
112		Ok(self.context.clone())
72	}113	}
73}114}
74115
75#[derive(Clone)]116#[derive(Trace, Clone)]
76pub struct ContextBuilder {117pub(crate) struct PackedContext {
118	captures: Cc<Vec<Thunk<Val>>>,
119	n_locals: u16,
120}
121impl PackedContext {
122	pub fn enter(self, sup_this: SupThis, build: impl FnOnce(&LocalsFrame, &Context)) -> Context {
123		let locals = LocalsFrame::new_once(self.n_locals);
124		let val = Context(Cc::new(ContextInternal {
125			captures: self.captures.clone(),
126			locals,
127			sup_this: Some(sup_this),
128		}));
129		build(&val.0.locals, &val);
130		val
131	}
132}
133#[derive(Trace, Clone, Educe, Debug)]
134#[educe(PartialEq)]
135pub(crate) struct PackedContextSupThis {
136	#[educe(PartialEq(method = Cc::ptr_eq))]
137	captures: Cc<Vec<Thunk<Val>>>,
138	n_locals: u16,
77	sup_this: Option<SupThis>,139	sup_this: Option<SupThis>,
78	bindings: Vec<Option<Thunk<Val>>>,
79	offset: u32,
80	parent: Option<Context>,
81}140}
141impl PackedContextSupThis {
142	pub fn enter(self, build: impl FnOnce(&LocalsFrame, &Context)) -> Context {
143		let locals = LocalsFrame::new_once(self.n_locals);
144		let val = Context(Cc::new(ContextInternal {
145			captures: self.captures.clone(),
146			locals,
147			sup_this: self.sup_this,
148		}));
149		build(&val.0.locals, &val);
150		val
151	}
152}
82153
83impl ContextBuilder {154impl Context {
84	pub fn new() -> Self {155	#[inline]
156	pub fn slot(&self, slot: LSlot) -> Thunk<Val> {
85		Self {157		match slot {
86			sup_this: None,158			LSlot::Local(i) => self.local(i),
87			bindings: Vec::new(),
88			offset: 0,159			LSlot::Capture(i) => self.capture(i),
89			parent: None,
90		}160		}
91	}161	}
92162	/// Read a local slot from the shared locals frame.
93	pub(crate) fn extend(parent: Context, capacity: usize) -> Self {163	///
164	/// # Panics
165	/// If the slot has not yet been filled. The analyzer guarantees
166	/// that slot indices are in range and that letrec setup completes
167	/// before the first read. A panic indicates an analyzer/runtime
168	/// invariant violation, not a user error.
169	#[inline]
170	pub fn local(&self, slot: LocalSlot) -> Thunk<Val> {
94		let offset = parent.0.offset + parent.0.bindings.len() as u32;171		match &*self.0.locals {
172			LocalsFrame::Once1(cell) => {
173				debug_assert_eq!(slot.0, 0, "Once1 only holds slot 0");
174				cell.get().expect("local read before letrec init").clone()
95		Self {175			}
96			sup_this: parent.0.sup_this.clone(),176			LocalsFrame::Once(cells) => cells[slot.0 as usize]
177				.get()
178				.expect("local read before letrec init")
179				.clone(),
97			bindings: Vec::with_capacity(capacity),180			LocalsFrame::Iter(cells) => cells.slots[slot.0 as usize]
98			offset,181				.borrow()
99			parent: Some(parent),182				.as_ref()
183				.expect("iter local read before iteration filled it")
184				.clone(),
100		}185		}
101	}186	}
102187
103	pub(crate) fn bind(&mut self, id: LocalId, value: Thunk<Val>) {188	/// Read a captured slot from this closure's capture pack.
104		debug_assert!(189	#[inline]
105			id.0 >= self.offset,190	pub fn capture(&self, slot: CaptureSlot) -> Thunk<Val> {
106			"cannot bind {id:?} below offset {}",
107			self.offset,
108		);
109		let local_idx = (id.0 - self.offset) as usize;
110		self.bindings.reserve(local_idx);
111		while self.bindings.len() <= local_idx {
112			self.bindings.push(None);191		(*self.0.captures)[slot.0 as usize].clone()
113		}
114		self.bindings[local_idx] = Some(value);
115	}192	}
116193
117	pub(crate) fn build(self) -> Context {194	pub fn sup_this(&self) -> Option<&SupThis> {
195		self.0.sup_this.as_ref()
196	}
197
198	pub fn try_sup_this(&self) -> Result<SupThis> {
118		Context(Cc::new(ContextInternal {199		self.0
200			.sup_this
201			.clone()
202			.ok_or_else(|| error!(CantUseSelfSupOutsideOfObject))
203	}
204
205	/// Build a root context: empty captures, externals filled into a
206	/// fresh Once locals frame in declaration order. Used once at
207	/// program entry to construct the context the analyzed root LIR
208	/// runs against.
209	pub(crate) fn root(externals: Vec<Thunk<Val>>) -> Self {
119			sup_this: self.sup_this,210		let n: u16 = externals
211			.len()
212			.try_into()
213			.expect("more than u16::MAX externals");
214		let cells: Vec<OnceCell<Thunk<Val>>> = externals
215			.into_iter()
120			bindings: self.bindings,216			.map(|t| {
217				let cell = OnceCell::new();
218				cell.set(t).map_err(|_| ()).expect("fresh cell");
219				cell
220			})
221			.collect();
222		debug_assert_eq!(cells.len(), n as usize);
121			offset: self.offset,223		let locals = Cc::new(LocalsFrame::Once(cells));
224		Self(Cc::new(ContextInternal {
225			captures: Cc::new(Vec::new()),
122			parent: self.parent,226			locals,
227			sup_this: None,
123		}))228		}))
124	}229	}
125230
126	pub(crate) fn build_sup_this(mut self, st: SupThis) -> Context {231	pub(crate) fn pack_captures(&self, shape: &ClosureShape) -> PackedContext {
127		self.sup_this = Some(st);232		PackedContext {
233			captures: Cc::new(pack_captures(self, &shape.captures)),
128		self.build()234			n_locals: shape.n_locals,
235		}
129	}236	}
237	pub(crate) fn pack_captures_sup_this(&self, shape: &ClosureShape) -> PackedContextSupThis {
238		PackedContextSupThis {
239			captures: Cc::new(pack_captures(self, &shape.captures)),
240			n_locals: shape.n_locals,
241			sup_this: self.0.sup_this.clone(),
242		}
243	}
244
245	pub(crate) fn enter_iter(
246		parent: &Context,
247		shape: &ClosureShape,
248		cb: impl FnOnce(IterContext) -> Result<()>,
249	) -> Result<()> {
250		let captures = Cc::new(pack_captures(parent, &shape.captures));
251		let locals = IterFrame::new(shape.n_locals);
252		cb(IterContext {
253			context: Self(Cc::new(ContextInternal {
254				captures,
255				locals: Cc::new(LocalsFrame::Iter(locals)),
256				sup_this: parent.0.sup_this.clone(),
257			})),
258		})
259	}
260
261	pub(crate) fn enter_using(parent: &Context, shape: &ClosureShape) -> Self {
262		debug_assert_eq!(shape.n_locals, 0);
263		if shape.captures.is_empty() {
264			if let LocalsFrame::Iter(i) = &*parent.0.locals {
265				i.captured.set(true);
266			}
267			// Value never uses captures, thus evaluating it against the parent gives the same result
268			return parent.clone();
269		}
270		let captures = Cc::new(pack_captures(parent, &shape.captures));
271		Self(Cc::new(ContextInternal {
272			captures,
273			locals: parent.0.locals.clone(),
274			sup_this: parent.0.sup_this.clone(),
275		}))
276	}
130}277}
131278
132impl Default for ContextBuilder {279fn pack_captures(parent: &Context, sources: &[LSlot]) -> Vec<Thunk<Val>> {
133	fn default() -> Self {
134		Self::new()280	sources.iter().map(|src| parent.slot(*src)).collect()
135	}
136}281}
137282
138pub struct InitialContextBuilder {283pub struct InitialContextBuilder {
139	builder: ContextBuilder,
140	externals: Vec<(IStr, LocalId)>,284	externals: Vec<(IStr, LocalId)>,
285	values: Vec<Thunk<Val>>,
141	next_id: u32,286	next_id: u32,
142}287}
143288
144impl InitialContextBuilder {289impl InitialContextBuilder {
145	pub(crate) fn new() -> Self {290	pub(crate) fn new() -> Self {
146		Self {291		Self {
147			builder: ContextBuilder::new(),
148			externals: Vec::new(),292			externals: Vec::new(),
293			values: Vec::new(),
149			next_id: 0,294			next_id: 0,
150		}295		}
151	}296	}
155		let id = LocalId(self.next_id);300		let id = LocalId(self.next_id);
156		self.next_id += 1;301		self.next_id += 1;
157		self.externals.push((name, id));302		self.externals.push((name, id));
158		self.builder.bind(id, value);303		self.values.push(value);
159	}304	}
160305
161	pub(crate) fn build(self) -> (ContextBuilder, Vec<(IStr, LocalId)>) {306	pub(crate) fn build(self) -> (Vec<(IStr, LocalId)>, Vec<Thunk<Val>>) {
162		(self.builder, self.externals)307		(self.externals, self.values)
163	}308	}
164}309}
165310

1use std::{cell::OnceCell, hash::Hasher, ptr::addr_of};1use std::{hash::Hasher, ptr::addr_of};
22
3use educe::Educe;
4use jrsonnet_gcmodule::{Cc, Trace};3use jrsonnet_gcmodule::Cc;
5
6use crate::{Result, bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue};
7
8#[derive(Trace, Educe)]
9#[educe(Clone)]
10pub struct Pending<V: Trace + 'static>(pub Cc<OnceCell<V>>);
11impl<T: Trace + 'static> Pending<T> {
12	pub fn new() -> Self {
13		Self(Cc::new(OnceCell::new()))
14	}
15	pub fn new_filled(v: T) -> Self {
16		let cell = OnceCell::new();
17		let _ = cell.set(v);
18		Self(Cc::new(cell))
19	}
20	/// # Panics
21	/// If wrapper is filled already
22	pub fn fill(self, value: T) {
23		self.0
24			.set(value)
25			.map_err(|_| ())
26			.expect("wrapper is filled already");
27	}
28}
29impl<T: Trace + 'static + Clone> Pending<T> {
30	/// # Panics
31	/// If wrapper is not yet filled
32	pub fn unwrap(&self) -> T {
33		self.0.get().cloned().expect("pending was not filled")
34	}
35	pub fn try_get(&self) -> Option<T> {
36		self.0.get().cloned()
37	}
38}
39
40impl<T: Trace + Clone> ThunkValue for Pending<T> {
41	type Output = T;
42
43	fn get(&self) -> Result<Self::Output> {
44		let Some(value) = self.0.get() else {
45			// TODO: Other error?
46			bail!(InfiniteRecursionDetected);
47		};
48		Ok(value.clone())
49	}
50}
51
52impl<T: Trace + 'static> Default for Pending<T> {
53	fn default() -> Self {
54		Self::new()
55	}
56}
574
58pub fn identity_hash<T, H: Hasher>(v: &Cc<T>, hasher: &mut H) {5pub fn identity_hash<T, H: Hasher>(v: &Cc<T>, hasher: &mut H) {
59	hasher.write_usize(addr_of!(**v) as usize);6	hasher.write_usize(addr_of!(**v) as usize);

1010
11use crate::{11use crate::{
12	ObjValue, ResolvePathOwned,12	ObjValue, ResolvePathOwned,
13	analyze::Diagnostic,
13	function::{CallLocation, FunctionSignature, ParamName},14	function::{CallLocation, FunctionSignature, ParamName},
14	stdlib::format::FormatError,15	stdlib::format::FormatError,
15	typed::TypeLocError,16	typed::TypeLocError,
112	CantUseSelfSupOutsideOfObject,113	CantUseSelfSupOutsideOfObject,
113114
114	#[error("static analysis errors: {}", .0.iter().map(|d| d.message.as_str()).collect::<Vec<_>>().join("; "))]115	#[error("static analysis errors: {}", .0.iter().map(|d| d.message.as_str()).collect::<Vec<_>>().join("; "))]
115	StaticAnalysisError(Vec<crate::analyze::Diagnostic>),116	StaticAnalysisError(Vec<Diagnostic>),
116	#[error("no super found")]117	#[error("no super found")]
117	NoSuperFound,118	NoSuperFound,
118119
119	#[error("for loop can only iterate over arrays")]120	#[error("for loop can only iterate over arrays")]
120	InComprehensionCanOnlyIterateOverArray,121	InComprehensionCanOnlyIterateOverArray,
122	#[error("(should not be visible) eager compspec evaluation failed due to captured context")]
123	EagerCompspecCaptured,
121124
122	#[error("array out of bounds: {0} is not within [0,{1})")]125	#[error("array out of bounds: {0} is not within [0,{1})")]
123	ArrayBoundsError(isize, u32),126	ArrayBoundsError(isize, u32),
397	};400	};
398}401}
399
400#[macro_export]
401macro_rules! runtime_error {
402	($l:literal$(, $($tt:tt)*)?) => {
403		$crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))
404	};
405}
406402

3use jrsonnet_types::ValType;3use jrsonnet_types::ValType;
44
5use super::{5use super::{
6	destructure::{self, evaluate_locals, evaluate_locals_unbound},6	destructure::{destruct, evaluate_locals_unbound, fill_letrec_binds},
7	evaluate_field_member_static, evaluate_field_member_unbound,7	evaluate_field_member_static, evaluate_field_member_unbound,
8};8};
9use crate::{9use crate::{
10	Context, ContextBuilder, ObjValue, ObjValueBuilder, Pending, Result, Thunk, Val,10	Context, ObjValue, ObjValueBuilder, Result, Thunk, Val,
11	analyze::{LArrComp, LBind, LCompSpec, LDestruct, LExpr, LFieldMember, LObjComp, LocalId},11	analyze::{
12		ClosureShape, LArrComp, LBind, LCompSpec, LDestruct, LExpr, LFieldMember, LObjComp,
13		LocalSlot,
14	},
12	arr::ArrValue,15	arr::ArrValue,
13	bail,16	bail,
14	error::ErrorKind::*,17	error::ErrorKind::*,
15	evaluate::evaluate,18	evaluate::{evaluate, evaluate_trivial},
16};19};
1720
18trait CompCollector {21trait CompCollector {
2225
23struct EagerArrCollector<'a> {26struct EagerArrCollector<'a> {
24	out: &'a mut Vec<Val>,27	out: &'a mut Vec<Val>,
28	value_shape: &'a ClosureShape,
25	value: &'a LExpr,29	value: &'a LExpr,
26}30}
27impl CompCollector for EagerArrCollector<'_> {31impl CompCollector for EagerArrCollector<'_> {
28	fn reserve(&mut self, size_hint: usize) {32	fn reserve(&mut self, size_hint: usize) {
29		self.out.reserve(size_hint);33		self.out.reserve(size_hint);
30	}34	}
31	fn collect(&mut self, ctx: Context) -> Result<()> {35	fn collect(&mut self, ctx: Context) -> Result<()> {
36		if let Some(v) = evaluate_trivial(self.value) {
37			self.out.push(v);
38			return Ok(());
39		}
40		if let LExpr::Slot(slot) = self.value {
41			self.out.push(ctx.slot(*slot).evaluate()?);
42			return Ok(());
43		}
44		let env = Context::enter_using(&ctx, self.value_shape);
32		self.out.push(evaluate(ctx, self.value)?);45		self.out.push(evaluate(env, self.value)?);
33		Ok(())46		Ok(())
34	}47	}
35}48}
3649
37struct LazyArrCollector<'a> {50struct LazyArrCollector<'a> {
38	out: &'a mut Vec<Thunk<Val>>,51	out: &'a mut Vec<Thunk<Val>>,
52	value_shape: &'a ClosureShape,
39	value: &'a Rc<LExpr>,53	value: &'a Rc<LExpr>,
40}54}
41impl CompCollector for LazyArrCollector<'_> {55impl CompCollector for LazyArrCollector<'_> {
42	fn reserve(&mut self, size_hint: usize) {56	fn reserve(&mut self, size_hint: usize) {
43		self.out.reserve(size_hint);57		self.out.reserve(size_hint);
44	}58	}
45	fn collect(&mut self, ctx: Context) -> Result<()> {59	fn collect(&mut self, ctx: Context) -> Result<()> {
60		if let Some(v) = evaluate_trivial(self.value) {
61			self.out.push(Thunk::evaluated(v));
62			return Ok(());
63		}
64		if let LExpr::Slot(slot) = self.value.as_ref() {
65			self.out.push(ctx.slot(*slot));
66			return Ok(());
67		}
68		let env = Context::enter_using(&ctx, self.value_shape);
46		let value_expr = self.value.clone();69		let value_expr = self.value.clone();
47		self.out.push(Thunk!(move || evaluate(ctx, &value_expr)));70		self.out.push(Thunk!(move || evaluate(env, &value_expr)));
48		Ok(())71		Ok(())
49	}72	}
50}73}
5174
52struct ObjCompCollectorStatic<'a> {75struct ObjCompCollectorStatic<'a> {
53	builder: &'a mut ObjValueBuilder,76	builder: &'a mut ObjValueBuilder,
77	frame_shape: &'a ClosureShape,
54	locals: &'a [LBind],78	locals: &'a [LBind],
55	field: &'a LFieldMember,79	field: &'a LFieldMember,
56}80}
59		self.builder.reserve_fields(guaranteed);83		self.builder.reserve_fields(guaranteed);
60	}84	}
61	fn collect(&mut self, inner_ctx: Context) -> Result<()> {85	fn collect(&mut self, inner_ctx: Context) -> Result<()> {
86		// Build the object's A-frame fresh per iteration: captures from
87		// the comp's iter ctx, locals = `this` (slot 0, unfilled in the
88		// static path) + member-locals via letrec.
62		let value_ctx = evaluate_locals(inner_ctx.clone(), self.locals);89		let value_ctx = inner_ctx
90			.pack_captures_sup_this(self.frame_shape)
91			.enter(|fill, ctx| {
92				fill_letrec_binds(fill, &ctx, self.locals);
93			});
63		evaluate_field_member_static(self.builder, inner_ctx, value_ctx, self.field)94		evaluate_field_member_static(self.builder, inner_ctx, value_ctx, self.field)
64	}95	}
65}96}
6697
67struct ObjCompCollectorUnbound<'a> {98struct ObjCompCollectorUnbound<'a> {
68	builder: &'a mut ObjValueBuilder,99	builder: &'a mut ObjValueBuilder,
100	frame_shape: Rc<ClosureShape>,
69	locals: Rc<Vec<LBind>>,101	locals: Rc<Vec<LBind>>,
70	this_id: Option<LocalId>,102	this_slot: Option<LocalSlot>,
71	field: &'a LFieldMember,103	field: &'a LFieldMember,
72}104}
73impl CompCollector for ObjCompCollectorUnbound<'_> {105impl CompCollector for ObjCompCollectorUnbound<'_> {
74	fn reserve(&mut self, guaranteed: usize) {106	fn reserve(&mut self, guaranteed: usize) {
75		self.builder.reserve_fields(guaranteed);107		self.builder.reserve_fields(guaranteed);
76	}108	}
77	fn collect(&mut self, inner_ctx: Context) -> Result<()> {109	fn collect(&mut self, inner_ctx: Context) -> Result<()> {
78		let uctx = evaluate_locals_unbound(inner_ctx.clone(), self.locals.clone(), self.this_id);110		let uctx = evaluate_locals_unbound(
111			&inner_ctx,
112			&self.frame_shape,
113			self.this_slot,
114			self.locals.clone(),
115		);
79		evaluate_field_member_unbound(self.builder, inner_ctx, uctx, self.field)116		evaluate_field_member_unbound(self.builder, inner_ctx, uctx, self.field)
100			0,137			0,
101			&mut ObjCompCollectorUnbound {138			&mut ObjCompCollectorUnbound {
102				builder: &mut builder,139				builder: &mut builder,
140				frame_shape: comp.frame_shape.clone(),
103				locals: comp.locals.clone(),141				locals: comp.locals.clone(),
104				this_id: comp.this,142				this_slot: comp.this,
105				field: &comp.field,143				field: &comp.field,
106			},144			},
107		)?;145		)?;
114			0,152			0,
115			&mut ObjCompCollectorStatic {153			&mut ObjCompCollectorStatic {
116				builder: &mut builder,154				builder: &mut builder,
155				frame_shape: &comp.frame_shape,
117				locals: &comp.locals,156				locals: &comp.locals,
118				field: &comp.field,157				field: &comp.field,
119			},158			},
126pub fn evaluate_arr_comp(ctx: Context, comp: &LArrComp) -> Result<Val> {165pub fn evaluate_arr_comp(ctx: Context, comp: &LArrComp) -> Result<Val> {
127	let cached_overs = cache_overs(&ctx, &comp.compspecs)?;166	let cached_overs = cache_overs(&ctx, &comp.compspecs)?;
128167
129	// In eager evaluation, Context is not captured, thus updates in CoW fashion will likely to success168	// Eager fast-path: when the comp has only `if` and `for { destruct: Full(_) }`
169	// specs, allocate one Iter A-frame per for-spec and re-set the slot
170	// per iteration as long as the frame's refcount stays at 1.
130	'eager: {171	'eager: {
131		let mut out = Vec::new();172		let mut out = Vec::new();
132173
147			0,188			0,
148			&mut EagerArrCollector {189			&mut EagerArrCollector {
149				out: &mut out,190				out: &mut out,
191				value_shape: &comp.value_shape,
150				value: &comp.value,192				value: &comp.value,
151			},193			},
152		)194		)
166		0,208		0,
167		&mut LazyArrCollector {209		&mut LazyArrCollector {
168			out: &mut items,210			out: &mut items,
211			value_shape: &comp.value_shape,
169			value: &comp.value,212			value: &comp.value,
170		},213		},
171	)?;214	)?;
221			}264			}
222		}265		}
223		LCompSpec::For { destruct, over, .. } => {266		LCompSpec::For {
267			frame_shape,
268			destruct,
269			over,
270			..
232			};280			};
233			let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;281			let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;
234			match destruct {282			match destruct {
235				LDestruct::Full(id) => {283				LDestruct::Full(slot) => {
236					let id = *id;284					Context::enter_iter(&ctx, frame_shape, |it| {
237					let mut inner_ctx = ContextBuilder::extend(ctx, 1).build();
238					for (i, item) in arr.iter().enumerate() {285						for (i, item) in arr.iter().enumerate() {
239						// TODO: reuse one ContextBuilder for full evaluate_compspecs pipeline286							let item = item?;
240						inner_ctx.cow_fill_binding(id, Thunk::evaluated(item?));287							let ctx = it.create(|f| {
288								f.set(*slot, Thunk::evaluated(item));
289							})?;
241						evaluate_compspecs_eager(290							evaluate_compspecs_eager(
242							inner_ctx.clone(),291								ctx,
243							specs,292								specs,
244							cached_overs,293								cached_overs,
245							idx + 1,294								idx + 1,
246							if i == 0 { inner_reserve } else { 0 },295								if i == 0 { inner_reserve } else { 0 },
247							collector,296								collector,
248						)?;297							)?;
249					}298						}
299						Ok(())
300					})?;
250				}301				}
251				// TODO: Should not be eager? CoW won't work here302				// TODO: Should not be eager? CoW won't work here
252				#[cfg(feature = "exp-destruct")]303				#[cfg(feature = "exp-destruct")]
284			}335			}
285		}336		}
286		LCompSpec::For { destruct, over, .. } => {337		LCompSpec::For {
338			frame_shape,
339			destruct: dst,
340			over,
341			..
342		} => {
295			};351			};
296			let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;352			let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;
297			for (i, item) in arr.iter().enumerate() {353			for (i, item) in arr.iter().enumerate() {
298				let item_val = item?;354				let item = item?;
299				let mut inner_builder = ContextBuilder::extend(ctx.clone(), 1);355				let inner_ctx = ctx.pack_captures_sup_this(frame_shape).enter(|fill, ctx| {
300				let fctx = Pending::new();
301				destructure::destruct(
302					destruct,356					destruct(dst, fill, Thunk::evaluated(item), &ctx);
303					Thunk::evaluated(item_val),
304					fctx.clone(),
305					&mut inner_builder,
306				);
307				let inner_ctx = inner_builder.build().into_future(fctx);357				});
308				evaluate_compspecs(358				evaluate_compspecs(
309					inner_ctx,359					inner_ctx,
310					specs,360					specs,

3use jrsonnet_gcmodule::Trace;3use jrsonnet_gcmodule::Trace;
44
5use crate::{5use crate::{
6	Context, ContextBuilder, Pending, Result, SupThis, Thunk, Unbound, Val,6	Context, LocalsFrame, PackedContext, Result, SupThis, Thunk, Unbound, Val,
7	analyze::{LBind, LDestruct, LDestructField, LDestructRest, LExpr, LocalId},7	analyze::{
8		ClosureShape, LBind, LDestruct, LDestructField, LDestructRest, LExpr, LLocalExpr, LocalSlot,
9	},
8	bail,10	bail,
9	evaluate::evaluate,11	evaluate::evaluate,
15	rest: Option<&LDestructRest>,17	rest: Option<&LDestructRest>,
16	end: &[LDestruct],18	end: &[LDestruct],
1719
20	fill: &LocalsFrame,
18	value: Thunk<Val>,21	value: Thunk<Val>,
19	fctx: Pending<Context>,
20	builder: &mut ContextBuilder,22	a_ctx: &Context,
21) {23) {
22	let min_len = start.len() + end.len();24	let min_len = start.len() + end.len();
23	let has_rest = rest.is_some();25	let has_rest = rest.is_some();
44		let full = full.clone();46		let full = full.clone();
45		destruct(47		destruct(
46			d,48			d,
49			fill,
47			Thunk!(move || Ok(full.evaluate()?.get(i as u32)?.expect("length is checked"))),50			Thunk!(move || Ok(full.evaluate()?.get(i as u32)?.expect("length is checked"))),
48			fctx.clone(),51			a_ctx,
49			builder,
50		);52		);
51	}53	}
5254
53	let start_len = start.len() as u32;55	let start_len = start.len() as u32;
54	let end_len = end.len() as u32;56	let end_len = end.len() as u32;
5557
56	if let Some(crate::analyze::LDestructRest::Keep(id)) = rest {58	if let Some(LDestructRest::Keep(slot)) = rest {
57		let full = full.clone();59		let full = full.clone();
58		builder.bind(60		fill.set(
59			*id,61			*slot,
60			Thunk!(move || {62			Thunk!(move || {
61				let full = full.evaluate()?;63				let full = full.evaluate()?;
62				let to = full.len() - end_len;64				let to = full.len() - end_len;
73		let full = full.clone();75		let full = full.clone();
74		destruct(76		destruct(
75			d,77			d,
78			fill,
76			Thunk!(move || {79			Thunk!(move || {
77				let full = full.evaluate()?;80				let full = full.evaluate()?;
78				Ok(full81				Ok(full
79					.get(full.len() - end_len + i as u32)?82					.get(full.len() - end_len + i as u32)?
80					.expect("length is checked"))83					.expect("length is checked"))
81			}),84			}),
82			fctx.clone(),85			a_ctx,
83			builder,
84		);86		);
85	}87	}
86}88}
90	fields: &[LDestructField],92	fields: &[LDestructField],
91	rest: Option<&LDestructRest>,93	rest: Option<&LDestructRest>,
9294
95	fill: &LocalsFrame,
93	value: Thunk<Val>,96	value: Thunk<Val>,
94	fctx: Pending<Context>,
95	builder: &mut ContextBuilder,97	a_ctx: &Context,
96) {98) {
97	use jrsonnet_interner::IStr;99	use jrsonnet_interner::IStr;
98	use rustc_hash::FxHashSet;100	use rustc_hash::FxHashSet;
124		Ok(obj)126		Ok(obj)
125	});127	});
126128
127	if let Some(crate::analyze::LDestructRest::Keep(id)) = rest {129	if let Some(LDestructRest::Keep(slot)) = rest {
128		let full = full.clone();130		let full = full.clone();
129		builder.bind(131		fill.set(
130			*id,132			*slot,
131			Thunk!(move || {133			Thunk!(move || {
132				let full = full.evaluate()?;134				let full = full.evaluate()?;
133				let mut out = ObjValueBuilder::new();135				let mut out = ObjValueBuilder::new();
140142
141	for field in fields {143	for field in fields {
142		let field_name = field.name.clone();144		let field_name = field.name.clone();
143		let default: Option<(Pending<Context>, Rc<LExpr>)> =145		let default_thunk: Option<Thunk<Val>> = field
144			field.default.as_ref().map(|e| (fctx.clone(), e.clone()));146			.default
147			.as_ref()
148			.map(|(shape, expr)| build_b_thunk(a_ctx, shape, expr.clone()));
149
145		let field_full = full.clone();150		let field_full = full.clone();
146		let value_thunk = Thunk!(move || {151		let value_thunk = Thunk!(move || {
147			let obj = field_full.evaluate()?;152			let obj = field_full.evaluate()?;
148			obj.get(field_name)?.map_or_else(153			obj.get(field_name)?.map_or_else(
149				|| {154				|| default_thunk.as_ref().expect("shape is checked").evaluate(),
150					let (fctx, expr) = default.as_ref().expect("shape is checked");
151					evaluate(fctx.unwrap(), expr)
152				},
153				Ok,155				Ok,
154			)156			)
155		});157		});
156158
157		if let Some(into) = &field.into {159		if let Some(into) = &field.into {
158			destruct(into, value_thunk, fctx.clone(), builder);160			destruct(into, fill, value_thunk, a_ctx);
159		} else {161		} else {
160			unreachable!("analyzer lowers object-destruct shorthands into `into`");162			unreachable!("analyzer lowers object-destruct shorthands into `into`");
161		}163		}
162	}164	}
163}165}
164166
165/// Bind a pre-built thunk to an [`LDestruct`] pattern, inserting one
166/// binding per [`LocalId`] the pattern introduces.
167///
168/// `fctx` is needed for object-destruct defaults (feature `exp-destruct`).
169#[allow(unused_variables)]167#[allow(unused_variables)]
170pub fn destruct(168pub fn destruct(d: &LDestruct, fill: &LocalsFrame, value: Thunk<Val>, a_ctx: &Context) {
171	d: &LDestruct,
172	value: Thunk<Val>,
173	fctx: Pending<Context>,
174	builder: &mut ContextBuilder,
175) {
176	match d {169	match d {
177		LDestruct::Full(id) => builder.bind(*id, value),170		LDestruct::Full(slot) => fill.set(*slot, value),
178		#[cfg(feature = "exp-destruct")]171		#[cfg(feature = "exp-destruct")]
179		LDestruct::Skip => {}172		LDestruct::Skip => {}
180		#[cfg(feature = "exp-destruct")]173		#[cfg(feature = "exp-destruct")]
181		LDestruct::Array { start, rest, end } => {174		LDestruct::Array { start, rest, end } => {
182			destruct_array(start, rest.as_ref(), end, value, fctx, builder)175			destruct_array(start, rest.as_ref(), end, fill, value, a_ctx)
183		}176		}
184		#[cfg(feature = "exp-destruct")]177		#[cfg(feature = "exp-destruct")]
185		LDestruct::Object { fields, rest } => {178		LDestruct::Object { fields, rest } => destruct_object(fields, rest.as_ref(), fill, value, a_ctx),
186			destruct_object(fields, rest.as_ref(), value, fctx, builder)
187		}
188	}179	}
189}180}
190181
191/// Bind one [`LBind`] as a lazy thunk that evaluates in the given
192/// future context. Mirrors the old `evaluate_dest` — one entry per
193/// binding in a `local … ;` frame.
194pub fn evaluate_dest(bind: &LBind, fctx: Pending<Context>, builder: &mut ContextBuilder) {182pub fn build_b_thunk(a_ctx: &Context, shape: &ClosureShape, expr: Rc<LExpr>) -> Thunk<Val> {
195	let value = bind.value.clone();183	let env = Context::enter_using(a_ctx, shape);
196	let fctx_clone = fctx.clone();
197	let thunk = Thunk!(move || {184	Thunk!(move || evaluate(env, &expr))
198		let ctx = fctx_clone.unwrap();
199		evaluate(ctx, &value)
200	});
201	destruct(&bind.destruct, thunk, fctx, builder);
202}185}
203186pub fn build_b_thunk_uno(a_ctx: &Context, shape: Rc<(ClosureShape, LExpr)>) -> Thunk<Val> {
204/// Bind each LBind's value as a lazy thunk. Mutually recursive locals187	let env = Context::enter_using(a_ctx, &shape.0);
205/// resolve lazily through the shared Pending<Context>.188	Thunk!(move || evaluate(env, &shape.1))
189}
190
206pub fn evaluate_locals(parent: Context, binds: &[LBind]) -> Context {191pub fn fill_letrec_binds(fill: &LocalsFrame, ctx: &Context, binds: &[LBind]) {
207	if binds.is_empty() {192	for bind in binds {
193		let value_thunk = build_b_thunk(ctx, &bind.value_shape, bind.value.clone());
194		destruct(&bind.destruct, fill, value_thunk, ctx);
195	}
196}
197
208		return parent;198pub fn evaluate_local_expr(parent: Context, l: &LLocalExpr) -> Result<Val> {
209	}
210	let fctx = Context::new_future();
211	let mut builder =199	let ctx = parent
200		.pack_captures_sup_this(&l.frame_shape)
212		ContextBuilder::extend(parent, binds.iter().map(|b| b.destruct.ids().len()).sum());201		.enter(|fill, ctx| {
213	for bind in binds {202			fill_letrec_binds(fill, ctx, &l.binds);
203		});
214		evaluate_dest(bind, fctx.clone(), &mut builder);204	evaluate(ctx, &l.body)
215	}205}
216	builder.build().into_future(fctx)
217}
218206
219pub trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}207pub trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}
220impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}208impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}
221209
222pub fn evaluate_locals_unbound(210pub fn evaluate_locals_unbound(
223	fctx: Context,211	outer: &Context,
212	frame_shape: &ClosureShape,
213	this_slot: Option<LocalSlot>,
224	locals: Rc<Vec<LBind>>,214	locals: Rc<Vec<LBind>>,
225	this_id: Option<LocalId>,
226) -> impl CloneableUnbound<Context> {215) -> impl CloneableUnbound<Context> {
227	#[derive(Trace, Clone)]216	#[derive(Trace, Clone)]
228	struct UnboundLocals {217	struct UnboundLocals {
229		fctx: Context,218		captures: PackedContext,
219		this_slot: Option<LocalSlot>,
230		locals: Rc<Vec<LBind>>,220		locals: Rc<Vec<LBind>>,
231		this_id: Option<LocalId>,
232	}221	}
233	impl Unbound for UnboundLocals {222	impl Unbound for UnboundLocals {
234		type Bound = Context;223		type Bound = Context;
235224
236		fn bind(&self, sup_this: SupThis) -> Result<Context> {225		fn bind(&self, sup_this: SupThis) -> Result<Context> {
237			let parent = self.fctx.clone();226			Ok(self.captures.clone().enter(sup_this, |fill, ctx| {
238
239			let fctx = Context::new_future();
240			let mut builder = ContextBuilder::extend(
241				parent,
242				self.locals.iter().map(|b| b.destruct.ids().len()).sum(),
243			);
244			for b in self.locals.iter() {
245				evaluate_dest(b, fctx.clone(), &mut builder);
246			}
247			if let Some(this_id) = self.this_id {227				if let Some(slot) = self.this_slot {
228					let this_obj = ctx.sup_this().expect("sup_this set above").this().clone();
248				builder.bind(this_id, Thunk::evaluated(Val::Obj(sup_this.this().clone())));229					fill.set(slot, Thunk::evaluated(Val::Obj(this_obj)));
249			}230				}
250			let ctx = builder.build_sup_this(sup_this).into_future(fctx);231				fill_letrec_binds(fill, ctx, &self.locals);
251			Ok(ctx)232			}))
252		}233		}
253	}234	}
254235
255	UnboundLocals {236	UnboundLocals {
256		fctx,237		captures: outer.pack_captures(frame_shape),
238		this_slot,
257		locals,239		locals,
258		this_id,
259	}240	}
260}241}
261242