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

--- a/crates/jrsonnet-evaluator/src/analyze.rs
+++ b/crates/jrsonnet-evaluator/src/analyze.rs
@@ -410,6 +410,15 @@
 		/// Is `over` does not depend on any variable introduced by an earlier for-spec in this comprehension chain
 		loop_invariant: bool,
 	},
+	#[cfg(feature = "exp-object-iteration")]
+	ForObj {
+		frame_shape: ClosureShape,
+		key: LocalSlot,
+		visibility: jrsonnet_ir::Visibility,
+		value: LDestruct,
+		over: LExpr,
+		loop_invariant: bool,
+	},
 }
 
 struct FrameAlloc<'s> {
@@ -1863,7 +1872,47 @@
 				(r, rest)
 			}
 			#[cfg(feature = "exp-object-iteration")]
-			CompSpec::ForObjSpec(_) => todo!(),
+			CompSpec::ForObjSpec(data) => {
+				let mut over_taint = AnalysisResult::default();
+				let over_l = analyze(&data.over, stack, &mut over_taint);
+				let loop_invariant = over_taint.local_dependent_depth > outer_depth;
+				taint.taint_by(over_taint);
+
+				let mut alloc = FrameAlloc::new(stack);
+				let closure = alloc.push_locals_closure();
+				let Some((_, key_slot)) = alloc.define_local(data.key.clone(), None) else {
+					stack.pop_closure(closure);
+					return go(idx + 1, specs, outer_depth, stack, taint, inside);
+				};
+				let Some(l_value) = alloc.alloc_destruct(&data.value) else {
+					stack.pop_closure(closure);
+					return go(idx + 1, specs, outer_depth, stack, taint, inside);
+				};
+				let mut pending = alloc.finish();
+
+				let var_analysis = AnalysisResult::default();
+				pending.record_spec_init(&LDestruct::Full(key_slot), var_analysis);
+				pending.record_spec_init(&l_value, var_analysis);
+
+				let body_frame = pending.finish();
+				let (r, mut rest) =
+					go(idx + 1, specs, outer_depth, body_frame.stack, taint, inside);
+				body_frame.finish();
+				let frame_shape = stack.pop_closure(closure);
+
+				rest.insert(
+					0,
+					LCompSpec::ForObj {
+						frame_shape,
+						key: key_slot,
+						visibility: data.visibility,
+						value: l_value,
+						over: over_l,
+						loop_invariant,
+					},
+				);
+				(r, rest)
+			}
 		}
 	}
 	let outer_depth = stack.depth;
@@ -1970,6 +2019,7 @@
 	use super::*;
 
 	#[test]
+	#[cfg(not(feature = "exp-null-coaelse"))]
 	fn snapshots() {
 		glob!("analysis_tests/*.jsonnet", |path| {
 			let code = fs::read_to_string(path).expect("read test file");

6	destructure::{destruct, evaluate_locals_unbound, fill_letrec_binds},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};
9#[cfg(feature = "exp-object-iteration")]
10use jrsonnet_interner::IStr;
11
9use crate::{12use crate::{
10	Context, ObjValue, ObjValueBuilder, Result, Thunk, Val,13	Context, ObjValue, ObjValueBuilder, Result, Thunk, Val,
18	evaluate::{evaluate, evaluate_trivial},21	evaluate::{evaluate, evaluate_trivial},
19};22};
23
24enum CachedOver {
25	Arr(ArrValue),
26	#[cfg(feature = "exp-object-iteration")]
27	Obj(ObjValue),
28}
2029
21trait CompCollector {30trait CompCollector {
22	fn reserve(&mut self, _guaranteed: usize) {}31	fn reserve(&mut self, _guaranteed: usize) {}
215	Ok(Val::arr(items))224	Ok(Val::arr(items))
216}225}
217226
218fn cache_overs(ctx: &Context, specs: &[LCompSpec]) -> Result<Vec<Option<ArrValue>>> {227fn cache_overs(ctx: &Context, specs: &[LCompSpec]) -> Result<Vec<Option<CachedOver>>> {
219	specs228	specs
220		.iter()229		.iter()
221		.map(|spec| {230		.map(|spec| {
229					let Val::Arr(arr) = val else {238					let Val::Arr(arr) = val else {
230						bail!(InComprehensionCanOnlyIterateOverArray)239						bail!(InComprehensionCanOnlyIterateOverArray)
231					};240					};
232					Some(arr)241					Some(CachedOver::Arr(arr))
233				}242				}
243				#[cfg(feature = "exp-object-iteration")]
244				LCompSpec::ForObj {
245					over,
246					loop_invariant: true,
247					..
248				} => {
249					let val = evaluate(ctx.clone(), over)?;
250					let Val::Obj(obj) = val else {
251						bail!(TypeMismatch(
252							"object iteration over",
253							vec![jrsonnet_types::ValType::Obj],
254							val.value_type(),
255						))
256					};
257					Some(CachedOver::Obj(obj))
258				}
234				_ => None,259				_ => None,
235			})260			})
236		})261		})
240fn evaluate_compspecs_eager(265fn evaluate_compspecs_eager(
241	ctx: Context,266	ctx: Context,
242	specs: &[LCompSpec],267	specs: &[LCompSpec],
243	cached_overs: &[Option<ArrValue>],268	cached_overs: &[Option<CachedOver>],
244	idx: usize,269	idx: usize,
245	guaranteed_reserve: usize,270	guaranteed_reserve: usize,
246	collector: &mut dyn CompCollector,271	collector: &mut dyn CompCollector,
269			over,294			over,
270			..295			..
271		} => {296		} => {
272			let arr = if let Some(cached) = &cached_overs[idx] {297			let arr = if let Some(CachedOver::Arr(cached)) = &cached_overs[idx] {
273				cached.clone()298				cached.clone()
274			} else {299			} else {
275				let arr_val = evaluate(ctx.clone(), over)?;300				let arr_val = evaluate(ctx.clone(), over)?;
304				_ => unreachable!("eager compspecs are not possible with non-full patterns"),329				_ => unreachable!("eager compspecs are not possible with non-full patterns"),
305			}330			}
306		}331		}
332		#[cfg(feature = "exp-object-iteration")]
333		LCompSpec::ForObj { .. } => {
334			unreachable!("eager compspecs filter rejects ForObj");
335		}
307	}336	}
308	Ok(())337	Ok(())
309}338}
310339
311fn evaluate_compspecs(340fn evaluate_compspecs(
312	ctx: Context,341	ctx: Context,
313	specs: &[LCompSpec],342	specs: &[LCompSpec],
314	cached_overs: &[Option<ArrValue>],343	cached_overs: &[Option<CachedOver>],
315	idx: usize,344	idx: usize,
316	guaranteed_reserve: usize,345	guaranteed_reserve: usize,
317	collector: &mut dyn CompCollector,346	collector: &mut dyn CompCollector,
340			over,369			over,
341			..370			..
342		} => {371		} => {
343			let arr = if let Some(cached) = &cached_overs[idx] {372			let arr = if let Some(CachedOver::Arr(cached)) = &cached_overs[idx] {
344				cached.clone()373				cached.clone()
345			} else {374			} else {
346				let arr_val = evaluate(ctx.clone(), over)?;375				let arr_val = evaluate(ctx.clone(), over)?;
365				)?;394				)?;
366			}395			}
367		}396		}
397		#[cfg(feature = "exp-object-iteration")]
398		LCompSpec::ForObj {
399			frame_shape,
400			key,
401			visibility,
402			value,
403			over,
404			..
405		} => {
406			use jrsonnet_ir::Visibility;
407			let obj = if let Some(CachedOver::Obj(cached)) = &cached_overs[idx] {
408				cached.clone()
409			} else {
410				let val = evaluate(ctx.clone(), over)?;
411				let Val::Obj(obj) = val else {
412					bail!(TypeMismatch(
413						"object iteration over",
414						vec![ValType::Obj],
415						val.value_type(),
416					))
417				};
418				obj
419			};
420			let fields = obj.fields_with_visibility(
421				#[cfg(feature = "exp-preserve-order")]
422				false,
423			);
424			let pairs: Vec<(IStr, Visibility)> = fields
425				.into_iter()
426				.filter(|(_, v)| match visibility {
427					Visibility::Normal => v.is_visible(),
428					Visibility::Hidden => !v.is_visible(),
429					Visibility::Unhide => true,
430				})
431				.collect();
432			let inner_reserve = guaranteed_reserve.max(1) * pairs.len();
433			for (i, (field_name, _)) in pairs.into_iter().enumerate() {
434				let key_val = Val::string(field_name.clone());
435				let value_thunk = obj
436					.get_lazy(field_name.clone())
437					.expect("field exists, just enumerated");
438				let inner_ctx = ctx.pack_captures_sup_this(frame_shape).enter(|fill, ctx| {
439					fill.set(*key, Thunk::evaluated(key_val));
440					destruct(value, fill, value_thunk, &ctx);
441				});
442				evaluate_compspecs(
443					inner_ctx,
444					specs,
445					cached_overs,
446					idx + 1,
447					if i == 0 { inner_reserve } else { 0 },
448					collector,
449				)?;
450			}
451		}
368	}452	}
369	Ok(())453	Ok(())
370}454}

--- a/crates/jrsonnet-evaluator/src/obj/mod.rs
+++ b/crates/jrsonnet-evaluator/src/obj/mod.rs
@@ -909,6 +909,56 @@
 
 		out
 	}
+	pub fn fields_with_visibility(
+		&self,
+		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
+	) -> Vec<(IStr, Visibility)> {
+		#[cfg(feature = "exp-preserve-order")]
+		if preserve_order {
+			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self
+				.fields_visibility()
+				.into_iter()
+				.enumerate()
+				.map(|(idx, (k, d))| {
+					(
+						(
+							k,
+							d.exists_visible.expect("non-existing fields filtered out"),
+						),
+						(d.sort_key(), idx),
+					)
+				})
+				.unzip();
+			keys.sort_unstable_by_key(|v| v.0);
+			for i in 0..fields.len() {
+				let x = fields[i].clone();
+				let mut j = i;
+				loop {
+					let k = keys[j].1;
+					keys[j].1 = j;
+					if k == i {
+						break;
+					}
+					fields[j] = fields[k].clone();
+					j = k;
+				}
+				fields[j] = x;
+			}
+			return fields;
+		}
+		let mut fields: Vec<_> = self
+			.fields_visibility()
+			.into_iter()
+			.map(|(k, d)| {
+				(
+					k,
+					d.exists_visible.expect("non-existing fields filtered out"),
+				)
+			})
+			.collect();
+		fields.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+		fields
+	}
 	pub fn fields_ex(
 		&self,
 		include_hidden: bool,

--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -441,6 +441,7 @@
 	use crate::{ParserSettings, parse};
 
 	#[test]
+	#[cfg(not(feature = "exp-null-coaelse"))]
 	fn snapshots() {
 		glob!("tests/*.jsonnet", |path| {
 			let input = fs::read_to_string(path).expect("read test file");