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

--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,10 @@
 .vscode
 .direnv
 
+# Nix artifacts
+/result
+/result-*
+
 cache
 
 jsonnet-cpp

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -7,7 +7,7 @@
 use super::ArrValue;
 use crate::{
 	error::ErrorKind::InfiniteRecursionDetected, evaluate, function::FuncVal, typed::Typed,
-	Context, Error, ObjValue, Result, Thunk, Val,
+	val::ThunkValue, Context, Error, ObjValue, Result, Thunk, Val,
 };
 
 pub trait ArrayLike: Any + Trace + Debug {
@@ -191,9 +191,25 @@
 			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}
 		};
 
-		let arr_thunk = self.clone();
-		Some(Thunk!(move || {
-			arr_thunk.get(index).transpose().expect("index checked")
+		#[derive(Trace)]
+		struct ExprArrThunk {
+			expr: ExprArray,
+			index: usize,
+		}
+		impl ThunkValue for ExprArrThunk {
+			type Output = Val;
+
+			fn get(&self) -> Result<Self::Output> {
+				self.expr
+					.get(self.index)
+					.transpose()
+					.expect("index checked")
+			}
+		}
+
+		Some(Thunk::new(ExprArrThunk {
+			expr: self.clone(),
+			index,
 		}))
 	}
 	fn get_cheap(&self, _index: usize) -> Option<Val> {
@@ -484,9 +500,22 @@
 			ArrayThunk::Waiting(()) | ArrayThunk::Pending => {}
 		};
 
-		let arr_thunk = self.clone();
-		Some(Thunk!(move || {
-			arr_thunk.get(index).transpose().expect("index checked")
+		#[derive(Trace)]
+		struct MappedArrayThunk<const WITH_INDEX: bool> {
+			arr: MappedArray<WITH_INDEX>,
+			index: usize,
+		}
+		impl<const WITH_INDEX: bool> ThunkValue for MappedArrayThunk<WITH_INDEX> {
+			type Output = Val;
+
+			fn get(&self) -> Result<Self::Output> {
+				self.arr.get(self.index).transpose().expect("index checked")
+			}
+		}
+
+		Some(Thunk::new(MappedArrayThunk {
+			arr: self.clone(),
+			index,
 		}))
 	}
 

--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -40,8 +40,9 @@
 impl<T: Trace + Clone> ThunkValue for Pending<T> {
 	type Output = T;
 
-	fn get(self: Box<Self>) -> Result<Self::Output> {
+	fn get(&self) -> Result<Self::Output> {
 		let Some(value) = self.0.get() else {
+			// TODO: Other error?
 			bail!(InfiniteRecursionDetected);
 		};
 		Ok(value.clone())

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -23,7 +23,7 @@
 	gc::WithCapacityExt as _,
 	identity_hash, in_frame,
 	operator::evaluate_add_op,
-	val::ArrValue,
+	val::{ArrValue, ThunkValue},
 	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,
 };
 
@@ -753,13 +753,45 @@
 		if !self.has_field_ex(key.clone(), true) {
 			return None;
 		}
-		let obj = self.clone();
+		#[derive(Trace)]
+		struct ObjFieldThunk {
+			obj: ObjValue,
+			key: IStr,
+		}
+		impl ThunkValue for ObjFieldThunk {
+			type Output = Val;
 
-		Some(Thunk!(move || Ok(obj.get(key)?.expect("field exists"))))
+			fn get(&self) -> Result<Self::Output> {
+				self.obj
+					.get(self.key.clone())
+					.transpose()
+					.expect("field existence checked")
+			}
+		}
+
+		Some(Thunk::new(ObjFieldThunk {
+			obj: self.clone(),
+			key,
+		}))
 	}
 	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {
-		let obj = self.clone();
-		Thunk!(move || obj.get_or_bail(key))
+		#[derive(Trace)]
+		struct ObjFieldThunk {
+			obj: ObjValue,
+			key: IStr,
+		}
+		impl ThunkValue for ObjFieldThunk {
+			type Output = Val;
+
+			fn get(&self) -> Result<Self::Output> {
+				self.obj.get_or_bail(self.key.clone())
+			}
+		}
+
+		Thunk::new(ObjFieldThunk {
+			obj: self.clone(),
+			key,
+		})
 	}
 	pub fn ptr_eq(a: &Self, b: &Self) -> bool {
 		Cc::ptr_eq(&a.0, &b.0)

2	cell::RefCell,2	cell::RefCell,
3	cmp::Ordering,3	cmp::Ordering,
4	fmt::{self, Debug, Display},4	fmt::{self, Debug, Display},
5	marker::PhantomData,
5	mem::replace,6	mem::replace,
6	num::NonZeroU32,7	num::NonZeroU32,
7	ops::Deref,8	ops::Deref,
8	rc::Rc,9	rc::Rc,
9};10};
1011
11use jrsonnet_gcmodule::{Acyclic, Cc, Trace, TraceBox};12use jrsonnet_gcmodule::{cc_dyn, Acyclic, Cc, Trace};
12use jrsonnet_interner::IStr;13use jrsonnet_interner::IStr;
13pub use jrsonnet_macros::Thunk;14pub use jrsonnet_macros::Thunk;
14use jrsonnet_types::ValType;15use jrsonnet_types::ValType;
2829
29pub trait ThunkValue: Trace {30pub trait ThunkValue: Trace {
30	type Output;31	type Output;
31	fn get(self: Box<Self>) -> Result<Self::Output>;32	fn get(&self) -> Result<Self::Output>;
32}33}
3334
34#[derive(Trace)]35#[derive(Trace)]
35pub struct ThunkValueClosure<D: Trace, O: 'static> {36enum MemoizedClusureThunkInner<D: Trace, T: Trace> {
37	Computed(T),
38	Errored(Error),
39	Waiting {
36	env: D,40		env: D,
37	// Carries no data, as it is not a real closure, all the41		// Carries no data, as it is not a real closure, all the
38	// captured environment is stored in `env` field.42		// captured environment is stored in `env` field.
39	#[trace(skip)]43		#[trace(skip)]
40	closure: fn(D) -> Result<O>,44		closure: fn(D) -> Result<T>,
45	},
46	Pending,
41}47}
42impl<D: Trace, O: 'static> ThunkValueClosure<D, O> {
43	pub fn new(env: D, closure: fn(D) -> Result<O>) -> Self {
44		Self { env, closure }
45	}
46}
47impl<D: Trace, O: 'static> ThunkValue for ThunkValueClosure<D, O> {
48	type Output = O;
49
50	fn get(self: Box<Self>) -> Result<Self::Output> {
51		(self.closure)(self.env)
52	}
53}
54
55#[derive(Trace)]
56enum ThunkInner<T: Trace> {
57	Computed(T),
58	Errored(Error),
59	Waiting(TraceBox<dyn ThunkValue<Output = T>>),
60	Pending,
61}
62
63/// Lazily evaluated value
64#[allow(clippy::module_name_repetitions)]48#[derive(Trace)]
65#[derive(Clone, Trace)]
66pub struct Thunk<T: Trace>(Cc<RefCell<ThunkInner<T>>>);49pub struct MemoizedClosureThunk<D: Trace, T: Trace>(RefCell<MemoizedClusureThunkInner<D, T>>);
67
68impl<T: Trace> Thunk<T> {50impl<D: Trace, T: Trace> MemoizedClosureThunk<D, T> {
69	pub fn evaluated(val: T) -> Self {
70		Self(Cc::new(RefCell::new(ThunkInner::Computed(val))))
71	}
72	pub fn new(f: impl ThunkValue<Output = T> + 'static) -> Self {51	pub fn new(env: D, closure: fn(D) -> Result<T>) -> Self {
73		Self(Cc::new(RefCell::new(ThunkInner::Waiting(TraceBox(52		Self(RefCell::new(MemoizedClusureThunkInner::Waiting {
74			Box::new(f),53			env,
54			closure,
75		)))))55		}))
76	}56	}
77	pub fn errored(e: Error) -> Self {
78		Self(Cc::new(RefCell::new(ThunkInner::Errored(e))))
79	}
80	pub fn result(res: Result<T, Error>) -> Self {
81		match res {
82			Ok(o) => Self::evaluated(o),
83			Err(e) => Self::errored(e),
84		}
85	}
86}57}
8758
88impl<T> Thunk<T>59impl<D: Trace, T: Trace + Clone> ThunkValue for MemoizedClosureThunk<D, T> {
89where60	type Output = T;
90	T: Clone + Trace,61
91{
92	pub fn force(&self) -> Result<()> {
93		self.evaluate()?;
94		Ok(())
95	}
96
97	/// Evaluate thunk, or return cached value
98	///
99	/// # Errors
100	///
101	/// - Lazy value evaluation returned error
102	/// - This method was called during inner value evaluation
103	pub fn evaluate(&self) -> Result<T> {62	fn get(&self) -> Result<Self::Output> {
104		match &*self.0.borrow() {63		match &*self.0.borrow() {
105			ThunkInner::Computed(v) => return Ok(v.clone()),64			MemoizedClusureThunkInner::Computed(v) => return Ok(v.clone()),
106			ThunkInner::Errored(e) => return Err(e.clone()),65			MemoizedClusureThunkInner::Errored(e) => return Err(e.clone()),
107			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),66			MemoizedClusureThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),
108			ThunkInner::Waiting(..) => (),67			MemoizedClusureThunkInner::Waiting { .. } => (),
109		};68		};
110		let ThunkInner::Waiting(value) = replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)69		let MemoizedClusureThunkInner::Waiting { env, closure } = replace(
70			&mut *self.0.borrow_mut(),
71			MemoizedClusureThunkInner::Pending,
111		else {72		) else {
112			unreachable!();73			unreachable!();
113		};74		};
114		let new_value = match value.0.get() {75		let new_value = match closure(env) {
115			Ok(v) => v,76			Ok(v) => v,
116			Err(e) => {77			Err(e) => {
117				*self.0.borrow_mut() = ThunkInner::Errored(e.clone());78				*self.0.borrow_mut() = MemoizedClusureThunkInner::Errored(e.clone());
118				return Err(e);79				return Err(e);
119			}80			}
120		};81		};
121		*self.0.borrow_mut() = ThunkInner::Computed(new_value.clone());82		*self.0.borrow_mut() = MemoizedClusureThunkInner::Computed(new_value.clone());
122		Ok(new_value)83		Ok(new_value)
123	}84	}
124}85}
86
87cc_dyn!(
88	/// Lazily evaluated value
89	#[derive(Clone)] Thunk<V: Trace>,
90	ThunkValue<Output = V>,
91	pub fn new() {...}
92);
93
94impl<T: Trace> Thunk<T> {
95	pub fn evaluated(val: T) -> Self
96	where
97		T: Clone,
98	{
99		#[derive(Trace)]
100		struct EvaluatedThunk<T: Trace>(T);
101		impl<T> ThunkValue for EvaluatedThunk<T>
102		where
103			T: Clone + Trace,
104		{
105			type Output = T;
106
107			fn get(&self) -> Result<Self::Output> {
108				Ok(self.0.clone())
109			}
110		}
111		Self::new(EvaluatedThunk(val))
112	}
113	pub fn errored(e: Error) -> Self {
114		#[derive(Trace)]
115		struct ErroredThunk<T: Trace>(Error, PhantomData<T>);
116		impl<T> ThunkValue for ErroredThunk<T>
117		where
118			T: Trace,
119		{
120			type Output = T;
121
122			fn get(&self) -> Result<Self::Output> {
123				Err(self.0.clone())
124			}
125		}
126		Self::new(ErroredThunk(e, PhantomData))
127	}
128	pub fn result(res: Result<T, Error>) -> Self
129	where
130		T: Clone,
131	{
132		match res {
133			Ok(o) => Self::evaluated(o),
134			Err(e) => Self::errored(e),
135		}
136	}
137}
138
139impl<T> Thunk<T>
140where
141	T: Clone + Trace,
142{
143	pub fn force(&self) -> Result<()> {
144		self.evaluate()?;
145		Ok(())
146	}
147
148	/// Evaluate thunk, or return cached value
149	///
150	/// # Errors
151	///
152	/// - Lazy value evaluation returned error
153	/// - This method was called during inner value evaluation
154	pub fn evaluate(&self) -> Result<T> {
155		self.0.get()
156	}
157}
125158
126pub trait ThunkMapper<Input>: Trace {159pub trait ThunkMapper<Input>: Trace {
127	type Output;160	type Output;
134	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>167	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>
135	where168	where
136		M: ThunkMapper<Input>,169		M: ThunkMapper<Input>,
137		M::Output: Trace,170		M::Output: Trace + Clone,
138	{171	{
139		let inner = self;172		let inner = self;
140		Thunk!(move || {173		Thunk!(move || {
145	}178	}
146}179}
147180
148impl<T: Trace> From<Result<T>> for Thunk<T> {181impl<T: Trace + Clone> From<Result<T>> for Thunk<T> {
149	fn from(value: Result<T>) -> Self {182	fn from(value: Result<T>) -> Self {
150		match value {183		match value {
151			Ok(o) => Self::evaluated(o),184			Ok(o) => Self::evaluated(o),
162	}195	}
163}196}
164197
165impl<T: Trace + Default> Default for Thunk<T> {198impl<T: Trace + Default + Clone> Default for Thunk<T> {
166	fn default() -> Self {199	fn default() -> Self {
167		Self::evaluated(T::default())200		Self::evaluated(T::default())
168	}201	}

--- a/crates/jrsonnet-formatter/src/comments.rs
+++ b/crates/jrsonnet-formatter/src/comments.rs
@@ -73,7 +73,10 @@
 						p!(out, str(" "));
 					}
 					p!(out, str("/* ") string(lines[0].trim().to_string()) str(" */"));
-					if matches!(loc, CommentLocation::AboveItem | CommentLocation::EndOfItems) {
+					if matches!(
+						loc,
+						CommentLocation::AboveItem | CommentLocation::EndOfItems
+					) {
 						p!(out, nl);
 					}
 				} else if !lines.is_empty() {

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -879,6 +879,6 @@
 	quote! {{
 		#move_check
 		#(#trace_check)*
-		::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::ThunkValueClosure::new(#env, #closure))
+		::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))
 	}}.into()
 }

--- a/xtask/src/sourcegen/mod.rs
+++ b/xtask/src/sourcegen/mod.rs
@@ -203,49 +203,57 @@
 			});
 
 			let mut type_positions: HashMap<String, usize> = HashMap::new();
-			let field_positions: Vec<_> = node.fields.iter().map(|field| {
-				let ty_str = field.ty().to_string();
-				let pos = *type_positions.get(&ty_str).unwrap_or(&0);
-				type_positions.insert(ty_str, pos + 1);
-				pos
-			}).collect();
+			let field_positions: Vec<_> = node
+				.fields
+				.iter()
+				.map(|field| {
+					let ty_str = field.ty().to_string();
+					let pos = *type_positions.get(&ty_str).unwrap_or(&0);
+					type_positions.insert(ty_str, pos + 1);
+					pos
+				})
+				.collect();
 
-			let methods = node.fields.iter().zip(field_positions.iter()).map(|(field, &pos)| {
-				let method_name = field.method_name(kinds);
-				let ty = field.ty();
+			let methods = node
+				.fields
+				.iter()
+				.zip(field_positions.iter())
+				.map(|(field, &pos)| {
+					let method_name = field.method_name(kinds);
+					let ty = field.ty();
 
-				if field.is_many() {
-					quote! {
-						pub fn #method_name(&self) -> AstChildren<#ty> {
-							support::children(&self.syntax)
+					if field.is_many() {
+						quote! {
+							pub fn #method_name(&self) -> AstChildren<#ty> {
+								support::children(&self.syntax)
+							}
 						}
-					}
-				} else if let Some(token_kind) = field.token_kind(kinds) {
-					quote! {
-						pub fn #method_name(&self) -> Option<#ty> {
-							support::token(&self.syntax, #token_kind)
+					} else if let Some(token_kind) = field.token_kind(kinds) {
+						quote! {
+							pub fn #method_name(&self) -> Option<#ty> {
+								support::token(&self.syntax, #token_kind)
+							}
 						}
-					}
-				} else if field.is_token_enum(grammar) {
-					quote! {
-						pub fn #method_name(&self) -> Option<#ty> {
-							support::token_child(&self.syntax)
+					} else if field.is_token_enum(grammar) {
+						quote! {
+							pub fn #method_name(&self) -> Option<#ty> {
+								support::token_child(&self.syntax)
+							}
 						}
-					}
-				} else if pos == 0 {
-					quote! {
-						pub fn #method_name(&self) -> Option<#ty> {
-							support::children(&self.syntax).next()
+					} else if pos == 0 {
+						quote! {
+							pub fn #method_name(&self) -> Option<#ty> {
+								support::children(&self.syntax).next()
+							}
 						}
-					}
-				} else {
-					quote! {
-						pub fn #method_name(&self) -> Option<#ty> {
-							support::children(&self.syntax).nth(#pos)
+					} else {
+						quote! {
+							pub fn #method_name(&self) -> Option<#ty> {
+								support::children(&self.syntax).nth(#pos)
+							}
 						}
 					}
-				}
-			});
+				});
 			(
 				quote! {
 					#[pretty_doc_comment_placeholder_workaround]