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

difftreelog

refactor only keep used spans in IR

uxonrmwzYaroslav Bolyukin2026-03-22parent: #44f6e2c.patch.diff
in: master

12 files changed

modifiedCargo.lockdiffbeforeafterboth
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -730,6 +730,7 @@
 version = "0.5.0-pre97"
 dependencies = [
  "insta",
+ "jrsonnet-gcmodule",
  "jrsonnet-ir",
  "peg",
 ]
modifiedcrates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -38,7 +38,7 @@
 		Self::new(RangeArray::empty())
 	}
 
-	pub fn expr(ctx: Context, exprs: Rc<Vec<Spanned<Expr>>>) -> Self {
+	pub fn expr(ctx: Context, exprs: Rc<Vec<Expr>>) -> Self {
 		Self::new(ExprArray::new(ctx, exprs))
 	}
modifiedcrates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth
before · crates/jrsonnet-evaluator/src/arr/spec.rs
1use std::rc::Rc;2use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace};34use jrsonnet_gcmodule::{Cc, Trace};5use jrsonnet_interner::{IBytes, IStr};6use jrsonnet_ir::{Expr, Spanned};78use super::ArrValue;9use crate::function::NativeFn;10use crate::{11	error::ErrorKind::InfiniteRecursionDetected,12	evaluate,13	typed::{IntoUntyped, Typed},14	val::ThunkValue,15	Context, Error, ObjValue, Result, Thunk, Val,16};1718pub trait ArrayLike: Any + Trace + Debug {19	fn len(&self) -> usize;20	fn is_empty(&self) -> bool {21		self.len() == 022	}23	fn get(&self, index: usize) -> Result<Option<Val>>;24	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;25	fn get_cheap(&self, index: usize) -> Option<Val>;2627	fn is_cheap(&self) -> bool;28}2930#[derive(Debug, Trace)]31pub struct SliceArray {32	pub(crate) inner: ArrValue,33	pub(crate) from: u32,34	pub(crate) to: u32,35	pub(crate) step: u32,36}3738impl SliceArray {39	fn map_idx(&self, index: usize) -> usize {40		self.from as usize + self.step as usize * index41	}42}43impl ArrayLike for SliceArray {44	fn len(&self) -> usize {45		(self.to - self.from).div_ceil(self.step) as usize46	}4748	fn get(&self, index: usize) -> Result<Option<Val>> {49		self.inner.get(self.map_idx(index))50	}5152	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {53		self.inner.get_lazy(self.map_idx(index))54	}5556	fn get_cheap(&self, index: usize) -> Option<Val> {57		self.inner.get_cheap(self.map_idx(index))58	}59	fn is_cheap(&self) -> bool {60		self.inner.is_cheap()61	}62}6364#[derive(Trace, Debug)]65pub struct CharArray(pub Vec<char>);66impl ArrayLike for CharArray {67	fn len(&self) -> usize {68		self.0.len()69	}7071	fn get(&self, index: usize) -> Result<Option<Val>> {72		Ok(self.get_cheap(index))73	}7475	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {76		self.get_cheap(index).map(Thunk::evaluated)77	}7879	fn get_cheap(&self, index: usize) -> Option<Val> {80		self.0.get(index).map(|v| Val::string(*v))81	}82	fn is_cheap(&self) -> bool {83		true84	}85}8687#[derive(Trace, Debug)]88pub struct BytesArray(pub IBytes);89impl ArrayLike for BytesArray {90	fn len(&self) -> usize {91		self.0.len()92	}9394	fn get(&self, index: usize) -> Result<Option<Val>> {95		Ok(self.get_cheap(index))96	}9798	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {99		self.get_cheap(index).map(Thunk::evaluated)100	}101102	fn get_cheap(&self, index: usize) -> Option<Val> {103		self.0.get(index).map(|v| Val::Num((*v).into()))104	}105	fn is_cheap(&self) -> bool {106		true107	}108}109110#[derive(Debug, Trace, Clone)]111enum ArrayThunk {112	Computed(Val),113	Errored(Error),114	Waiting,115	Pending,116}117118#[derive(Debug, Trace, Clone)]119pub struct ExprArray {120	ctx: Context,121	src: Rc<Vec<Spanned<Expr>>>,122	cached: Cc<RefCell<Vec<ArrayThunk>>>,123}124impl ExprArray {125	pub fn new(ctx: Context, src: Rc<Vec<Spanned<Expr>>>) -> Self {126		Self {127			ctx,128			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),129			src,130		}131	}132}133impl ArrayLike for ExprArray {134	fn len(&self) -> usize {135		self.cached.borrow().len()136	}137	fn get(&self, index: usize) -> Result<Option<Val>> {138		if index >= self.len() {139			return Ok(None);140		}141		match &self.cached.borrow()[index] {142			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),143			ArrayThunk::Errored(e) => return Err(e.clone()),144			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),145			ArrayThunk::Waiting => {}146		}147148		let ArrayThunk::Waiting =149			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)150		else {151			unreachable!()152		};153154		let new_value = match evaluate(self.ctx.clone(), &self.src[index]) {155			Ok(v) => v,156			Err(e) => {157				self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());158				return Err(e);159			}160		};161		self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());162		Ok(Some(new_value))163	}164	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {165		#[derive(Trace)]166		struct ExprArrThunk {167			expr: ExprArray,168			index: usize,169		}170		impl ThunkValue for ExprArrThunk {171			type Output = Val;172173			fn get(&self) -> Result<Self::Output> {174				self.expr175					.get(self.index)176					.transpose()177					.expect("index checked")178			}179		}180181		if index >= self.len() {182			return None;183		}184		match &self.cached.borrow()[index] {185			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),186			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),187			ArrayThunk::Waiting | ArrayThunk::Pending => {}188		}189190		Some(Thunk::new(ExprArrThunk {191			expr: self.clone(),192			index,193		}))194	}195	fn get_cheap(&self, _index: usize) -> Option<Val> {196		None197	}198	fn is_cheap(&self) -> bool {199		false200	}201}202203#[derive(Trace, Debug)]204pub struct ExtendedArray {205	pub a: ArrValue,206	pub b: ArrValue,207	split: usize,208	len: usize,209}210impl ExtendedArray {211	pub fn new(a: ArrValue, b: ArrValue) -> Self {212		let a_len = a.len();213		let b_len = b.len();214		Self {215			a,216			b,217			split: a_len,218			len: a_len.checked_add(b_len).expect("too large array value"),219		}220	}221}222223struct WithExactSize<I>(I, usize);224impl<I, T> Iterator for WithExactSize<I>225where226	I: Iterator<Item = T>,227{228	type Item = T;229230	fn next(&mut self) -> Option<Self::Item> {231		self.0.next()232	}233	fn nth(&mut self, n: usize) -> Option<Self::Item> {234		self.0.nth(n)235	}236	fn size_hint(&self) -> (usize, Option<usize>) {237		(self.1, Some(self.1))238	}239}240impl<I> DoubleEndedIterator for WithExactSize<I>241where242	I: DoubleEndedIterator,243{244	fn next_back(&mut self) -> Option<Self::Item> {245		self.0.next_back()246	}247	fn nth_back(&mut self, n: usize) -> Option<Self::Item> {248		self.0.nth_back(n)249	}250}251impl<I> ExactSizeIterator for WithExactSize<I>252where253	I: Iterator,254{255	fn len(&self) -> usize {256		self.1257	}258}259impl ArrayLike for ExtendedArray {260	fn get(&self, index: usize) -> Result<Option<Val>> {261		if self.split > index {262			self.a.get(index)263		} else {264			self.b.get(index - self.split)265		}266	}267	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {268		if self.split > index {269			self.a.get_lazy(index)270		} else {271			self.b.get_lazy(index - self.split)272		}273	}274275	fn len(&self) -> usize {276		self.len277	}278279	fn get_cheap(&self, index: usize) -> Option<Val> {280		if self.split > index {281			self.a.get_cheap(index)282		} else {283			self.b.get_cheap(index - self.split)284		}285	}286	fn is_cheap(&self) -> bool {287		self.a.is_cheap() && self.b.is_cheap()288	}289}290291#[derive(Trace, Debug)]292pub struct LazyArray(pub Vec<Thunk<Val>>);293impl ArrayLike for LazyArray {294	fn len(&self) -> usize {295		self.0.len()296	}297	fn get(&self, index: usize) -> Result<Option<Val>> {298		let Some(v) = self.0.get(index) else {299			return Ok(None);300		};301		v.evaluate().map(Some)302	}303	fn get_cheap(&self, _index: usize) -> Option<Val> {304		None305	}306	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {307		self.0.get(index).cloned()308	}309	fn is_cheap(&self) -> bool {310		false311	}312}313314#[derive(Trace, Debug)]315pub struct EagerArray(pub Vec<Val>);316impl ArrayLike for EagerArray {317	fn len(&self) -> usize {318		self.0.len()319	}320321	fn get(&self, index: usize) -> Result<Option<Val>> {322		Ok(self.0.get(index).cloned())323	}324325	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {326		self.0.get(index).cloned().map(Thunk::evaluated)327	}328329	fn get_cheap(&self, index: usize) -> Option<Val> {330		self.0.get(index).cloned()331	}332	fn is_cheap(&self) -> bool {333		true334	}335}336337/// Inclusive range type338#[derive(Debug, Trace, PartialEq, Eq)]339pub struct RangeArray {340	start: i32,341	end: i32,342}343impl RangeArray {344	pub fn empty() -> Self {345		Self::new_exclusive(0, 0)346	}347	pub fn new_exclusive(start: i32, end: i32) -> Self {348		end.checked_sub(1)349			.map_or_else(Self::empty, |end| Self { start, end })350	}351	pub fn new_inclusive(start: i32, end: i32) -> Self {352		Self { start, end }353	}354	fn range(&self) -> impl ExactSizeIterator<Item = i32> + DoubleEndedIterator {355		WithExactSize(356			self.start..=self.end,357			(self.end as usize)358				.wrapping_sub(self.start as usize)359				.wrapping_add(1),360		)361	}362}363364impl ArrayLike for RangeArray {365	fn len(&self) -> usize {366		self.range().len()367	}368	fn is_empty(&self) -> bool {369		self.range().len() == 0370	}371372	fn get(&self, index: usize) -> Result<Option<Val>> {373		Ok(self.get_cheap(index))374	}375376	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {377		self.get_cheap(index).map(Thunk::evaluated)378	}379380	fn get_cheap(&self, index: usize) -> Option<Val> {381		self.range().nth(index).map(|i| Val::Num(i.into()))382	}383	fn is_cheap(&self) -> bool {384		true385	}386}387388#[derive(Debug, Trace)]389pub struct ReverseArray(pub ArrValue);390impl ArrayLike for ReverseArray {391	fn len(&self) -> usize {392		self.0.len()393	}394395	fn get(&self, index: usize) -> Result<Option<Val>> {396		self.0.get(self.0.len() - index - 1)397	}398399	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {400		self.0.get_lazy(self.0.len() - index - 1)401	}402403	fn get_cheap(&self, index: usize) -> Option<Val> {404		self.0.get_cheap(self.0.len() - index - 1)405	}406	fn is_cheap(&self) -> bool {407		self.0.is_cheap()408	}409}410411#[derive(Trace, Clone, Debug)]412pub enum ArrayMapper {413	Plain(NativeFn!((Val) -> Val)),414	WithIndex(NativeFn!((u32, Val) -> Val)),415}416417#[derive(Trace, Debug, Clone)]418pub struct MappedArray {419	inner: ArrValue,420	cached: Cc<RefCell<Vec<ArrayThunk>>>,421	mapper: ArrayMapper,422}423impl MappedArray {424	pub fn new(inner: ArrValue, mapper: ArrayMapper) -> Self {425		let len = inner.len();426		Self {427			inner,428			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; len])),429			mapper,430		}431	}432	fn evaluate(&self, index: usize, value: Val) -> Result<Val> {433		match &self.mapper {434			ArrayMapper::Plain(f) => f.call(value),435			ArrayMapper::WithIndex(f) => f.call(index as u32, value),436		}437	}438}439impl ArrayLike for MappedArray {440	fn len(&self) -> usize {441		self.cached.borrow().len()442	}443444	fn get(&self, index: usize) -> Result<Option<Val>> {445		if index >= self.len() {446			return Ok(None);447		}448		match &self.cached.borrow()[index] {449			ArrayThunk::Computed(c) => return Ok(Some(c.clone())),450			ArrayThunk::Errored(e) => return Err(e.clone()),451			ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),452			ArrayThunk::Waiting => {}453		}454455		let ArrayThunk::Waiting =456			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)457		else {458			unreachable!()459		};460461		let val = self462			.inner463			.get(index)464			.transpose()465			.expect("index checked")466			.and_then(|r| self.evaluate(index, r));467468		let new_value = match val {469			Ok(v) => v,470			Err(e) => {471				self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());472				return Err(e);473			}474		};475		self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());476		Ok(Some(new_value))477	}478	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {479		#[derive(Trace)]480		struct MappedArrayThunk {481			arr: MappedArray,482			index: usize,483		}484		impl ThunkValue for MappedArrayThunk {485			type Output = Val;486487			fn get(&self) -> Result<Self::Output> {488				self.arr.get(self.index).transpose().expect("index checked")489			}490		}491492		if index >= self.len() {493			return None;494		}495		match &self.cached.borrow()[index] {496			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),497			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),498			ArrayThunk::Waiting | ArrayThunk::Pending => {}499		}500501		Some(Thunk::new(MappedArrayThunk {502			arr: self.clone(),503			index,504		}))505	}506507	fn get_cheap(&self, _index: usize) -> Option<Val> {508		None509	}510	fn is_cheap(&self) -> bool {511		false512	}513}514515#[derive(Trace, Debug)]516pub struct RepeatedArray {517	data: ArrValue,518	repeats: usize,519	total_len: usize,520}521impl RepeatedArray {522	pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {523		let total_len = data.len().checked_mul(repeats)?;524		Some(Self {525			data,526			repeats,527			total_len,528		})529	}530}531532impl ArrayLike for RepeatedArray {533	fn len(&self) -> usize {534		self.total_len535	}536537	fn get(&self, index: usize) -> Result<Option<Val>> {538		if index > self.total_len {539			return Ok(None);540		}541		self.data.get(index % self.data.len())542	}543544	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {545		if index > self.total_len {546			return None;547		}548		self.data.get_lazy(index % self.data.len())549	}550551	fn get_cheap(&self, index: usize) -> Option<Val> {552		if index > self.total_len {553			return None;554		}555		self.data.get_cheap(index % self.data.len())556	}557	fn is_cheap(&self) -> bool {558		self.data.is_cheap()559	}560}561562#[derive(Trace, Debug)]563pub struct PickObjectValues {564	obj: ObjValue,565	keys: Vec<IStr>,566}567568impl PickObjectValues {569	pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {570		Self { obj, keys }571	}572}573574impl ArrayLike for PickObjectValues {575	fn len(&self) -> usize {576		self.keys.len()577	}578579	fn get(&self, index: usize) -> Result<Option<Val>> {580		let Some(key) = self.keys.get(index) else {581			return Ok(None);582		};583		Ok(Some(self.obj.get_or_bail(key.clone())?))584	}585586	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {587		let key = self.keys.get(index)?;588		Some(self.obj.get_lazy_or_bail(key.clone()))589	}590591	fn get_cheap(&self, _index: usize) -> Option<Val> {592		None593	}594595	fn is_cheap(&self) -> bool {596		false597	}598}599600#[derive(Trace, Debug)]601pub struct PickObjectKeyValues {602	obj: ObjValue,603	keys: Vec<IStr>,604}605606impl PickObjectKeyValues {607	pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {608		Self { obj, keys }609	}610}611612#[derive(Typed, IntoUntyped)]613pub struct KeyValue {614	key: IStr,615	value: Thunk<Val>,616}617618impl ArrayLike for PickObjectKeyValues {619	fn len(&self) -> usize {620		self.keys.len()621	}622623	fn get(&self, index: usize) -> Result<Option<Val>> {624		let Some(key) = self.keys.get(index) else {625			return Ok(None);626		};627		Ok(Some(628			KeyValue::into_untyped(KeyValue {629				key: key.clone(),630				value: Thunk::evaluated(self.obj.get_or_bail(key.clone())?),631			})632			.expect("convertible"),633		))634	}635636	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {637		let key = self.keys.get(index)?;638		// Nothing can fail in the key part, yet value is still639		// lazy-evaluated640		Some(Thunk::evaluated(641			KeyValue::into_untyped(KeyValue {642				key: key.clone(),643				value: self.obj.get_lazy_or_bail(key.clone()),644			})645			.expect("convertible"),646		))647	}648649	fn get_cheap(&self, _index: usize) -> Option<Val> {650		None651	}652653	fn is_cheap(&self) -> bool {654		false655	}656}
modifiedcrates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -139,7 +139,7 @@
 			if let Expr::Str(s) = &***v {
 				out.0.push(Import {
 					path: ResolvePathOwned::Str(s.to_string()),
-					expression: matches!(&**expr, Expr::Import(ImportKind::Normal, _)),
+					expression: todo!(),
 				});
 			}
 			// Non-string import will fail in runtime
modifiedcrates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -53,7 +53,7 @@
 			Expr::Str(_)
 			| Expr::Num(_)
 			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,
-			Expr::Arr(a) => a.iter().all(|e| is_trivial(&**e)),
+			Expr::Arr(a) => a.iter().all(|e| is_trivial(&*e)),
 			_ => false,
 		}
 	}
@@ -71,7 +71,7 @@
 			}
 			Val::Arr(ArrValue::eager(
 				n.iter()
-					.map(|e| evaluate_trivial(&**e))
+					.map(|e| evaluate_trivial(&*e))
 					.map(|e| e.expect("checked trivial"))
 					.collect(),
 			))
@@ -80,12 +80,7 @@
 	})
 }
 
-pub fn evaluate_method(
-	ctx: Context,
-	name: IStr,
-	params: ExprParams,
-	body: Rc<Spanned<Expr>>,
-) -> Val {
+pub fn evaluate_method(ctx: Context, name: IStr, params: ExprParams, body: Rc<Expr>) -> Val {
 	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
 		name,
 		ctx,
@@ -97,18 +92,21 @@
 pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {
 	Ok(match field_name {
 		FieldName::Fixed(n) => Some(n.clone()),
-		FieldName::Dyn(expr) => in_frame(
-			CallLocation::new(&expr.span()),
-			|| "evaluating field name".to_string(),
-			|| {
-				let value = evaluate(ctx, expr)?;
-				if matches!(value, Val::Null) {
-					Ok(None)
-				} else {
-					Ok(Some(IStr::from_untyped(value)?))
-				}
-			},
-		)?,
+		FieldName::Dyn(expr) => {
+			// FIXME: Span
+			let value = evaluate(ctx, expr)?;
+			if matches!(value, Val::Null) {
+				None
+			} else {
+				Some(IStr::from_untyped(value)?)
+			}
+		} //
+		  // 	in_frame(
+		  // 	CallLocation::new(&expr.span()),
+		  // 	|| "evaluating field name".to_string(),
+		  // 	|| {
+		  // 	},
+		  // )?,
 	})
 }
 
@@ -119,46 +117,48 @@
 ) -> Result<()> {
 	match specs.first() {
 		None => callback(ctx)?,
-		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
+		Some(CompSpec::IfSpec(Spanned(IfSpecData(cond), _))) => {
 			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {
 				evaluate_comp(ctx, &specs[1..], callback)?;
 			}
 		}
-		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {
-			Val::Arr(list) => {
-				for item in list.iter_lazy() {
-					let fctx = Pending::new();
-					let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
-					destruct(var, item, fctx.clone(), &mut new_bindings)?;
-					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
+		Some(CompSpec::ForSpec(Spanned(ForSpecData(var, expr), _))) => {
+			match evaluate(ctx.clone(), expr)? {
+				Val::Arr(list) => {
+					for item in list.iter_lazy() {
+						let fctx = Pending::new();
+						let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
+						destruct(var, item, fctx.clone(), &mut new_bindings)?;
+						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
 
-					evaluate_comp(ctx, &specs[1..], callback)?;
+						evaluate_comp(ctx, &specs[1..], callback)?;
+					}
 				}
-			}
-			#[cfg(feature = "exp-object-iteration")]
-			Val::Obj(obj) => {
-				for field in obj.fields(
-					// TODO: Should there be ability to preserve iteration order?
-					#[cfg(feature = "exp-preserve-order")]
-					false,
-				) {
-					let fctx = Pending::new();
-					let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
-					let obj = obj.clone();
-					let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
-						Thunk::evaluated(Val::string(field.clone())),
-						Thunk!(move || obj.get(field).transpose().expect(
-							"field exists, as field name was obtained from object.fields()",
-						)),
-					])));
-					destruct(var, value, fctx.clone(), &mut new_bindings)?;
-					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
+				#[cfg(feature = "exp-object-iteration")]
+				Val::Obj(obj) => {
+					for field in obj.fields(
+						// TODO: Should there be ability to preserve iteration order?
+						#[cfg(feature = "exp-preserve-order")]
+						false,
+					) {
+						let fctx = Pending::new();
+						let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
+						let obj = obj.clone();
+						let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
+							Thunk::evaluated(Val::string(field.clone())),
+							Thunk!(move || obj.get(field).transpose().expect(
+								"field exists, as field name was obtained from object.fields()",
+							)),
+						])));
+						destruct(var, value, fctx.clone(), &mut new_bindings)?;
+						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
 
-					evaluate_comp(ctx, &specs[1..], callback)?;
+						evaluate_comp(ctx, &specs[1..], callback)?;
+					}
 				}
+				_ => bail!(InComprehensionCanOnlyIterateOverArray),
 			}
-			_ => bail!(InComprehensionCanOnlyIterateOverArray),
-		},
+		}
 	}
 	Ok(())
 }
@@ -221,7 +221,7 @@
 			#[derive(Trace)]
 			struct UnboundValue<B: Trace> {
 				uctx: B,
-				value: Rc<Spanned<Expr>>,
+				value: Rc<Expr>,
 				name: IStr,
 			}
 			impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
@@ -235,7 +235,8 @@
 				.field(name.clone())
 				.with_add(*plus)
 				.with_visibility(*visibility)
-				.with_location(value.span())
+				// FIXME
+				// .with_location(value.span())
 				.bindable(UnboundValue {
 					uctx,
 					value: value.clone(),
@@ -251,7 +252,7 @@
 			#[derive(Trace)]
 			struct UnboundMethod<B: Trace> {
 				uctx: B,
-				value: Rc<Spanned<Expr>>,
+				value: Rc<Expr>,
 				params: ExprParams,
 				name: IStr,
 			}
@@ -270,7 +271,7 @@
 			builder
 				.field(name.clone())
 				.with_visibility(*visibility)
-				.with_location(value.span())
+				// .with_location(value.span())
 				.bindable(UnboundMethod {
 					uctx,
 					value: value.clone(),
@@ -337,7 +338,7 @@
 
 pub fn evaluate_apply(
 	ctx: Context,
-	value: &Spanned<Expr>,
+	value: &Expr,
 	args: &ArgsDesc,
 	loc: CallLocation<'_>,
 	tailstrict: bool,
@@ -379,16 +380,16 @@
 	Ok(())
 }
 
-pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {
+pub fn evaluate_named_param(ctx: Context, expr: &Expr, name: ParamName) -> Result<Val> {
 	match name {
 		ParamName::Named(name) => evaluate_named(ctx, expr, name),
 		ParamName::Unnamed => evaluate(ctx, expr),
 	}
 }
 
-pub fn evaluate_named(ctx: Context, expr: &Spanned<Expr>, name: IStr) -> Result<Val> {
+pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {
 	use Expr::*;
-	Ok(match &**expr {
+	Ok(match &*expr {
 		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
 		_ => evaluate(ctx, expr)?,
 	})
@@ -417,7 +418,7 @@
 		// because the standalone super literal is not supported, that is because in other
 		// implementations `in super` treated differently from `in smth_else`.
 		BinaryOp(bin)
-			if matches!(&*bin.rhs, Expr::Literal(LiteralType::Super))
+			if matches!(&bin.rhs, Expr::Literal(LiteralType::Super))
 				&& bin.op == BinaryOpType::In =>
 		{
 			let sup_this = ctx.try_sup_this()?;
@@ -433,12 +434,12 @@
 		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
 		Var(name) => in_frame(
 			CallLocation::new(&name.span()),
-			|| format!("local <{name}> access"),
+			|| format!("local <{}> access", &**name),
 			|| ctx.binding((**name).clone())?.evaluate(),
 		)?,
 		Index { indexable, parts } => ensure_sufficient_stack(|| {
 			let mut parts = parts.iter();
-			let mut indexable = if matches!(&***indexable, Expr::Literal(LiteralType::Super)) {
+			let mut indexable = if matches!(&**indexable, Expr::Literal(LiteralType::Super)) {
 				let part = parts.next().expect("at least part should exist");
 				// sup_this existence check might also be skipped here for null-coalesce...
 				// But I believe this might cause errors.
@@ -463,7 +464,7 @@
 				let name = name.into_flat();
 				match sup_this
 					.get_super(name.clone())
-					.with_description_src(&part.value, || format!("field <{name}> access"))?
+					.with_description_src(&part.span, || format!("field <{name}> access"))?
 				{
 					Some(v) => v,
 					#[cfg(feature = "exp-null-coaelse")]
@@ -485,7 +486,7 @@
 				indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {
 					(Val::Obj(v), Val::Str(key)) => match v
 						.get(key.clone().into_flat())
-						.with_description_src(&part.value, || format!("field <{key}> access"))?
+						.with_description_src(&part.span, || format!("field <{key}> access"))?
 					{
 						Some(v) => v,
 						#[cfg(feature = "exp-null-coaelse")]
@@ -497,7 +498,7 @@
 								key.clone().into_flat(),
 								suggestions,
 							)))
-							.with_description_src(&part.value, || format!("field <{key}> access"));
+							.with_description_src(&part.span, || format!("field <{key}> access"));
 						}
 					},
 					(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(
@@ -605,17 +606,21 @@
 			evaluate_assert(ctx.clone(), &assert.assert)?;
 			evaluate(ctx, &assert.rest)?
 		}
-		ErrorStmt(e) => in_frame(
-			CallLocation::new(&e.span()),
+		ErrorStmt(s, e) => in_frame(
+			CallLocation::new(&s),
 			|| "error statement".to_owned(),
 			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
 		)?,
 		IfElse(if_else) => {
-			if in_frame(
-				CallLocation::new(&if_else.cond.0.span()),
-				|| "if condition".to_owned(),
-				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?),
-			)? {
+			if
+			// FIXME
+			//in_frame(
+			// CallLocation::new(&if_else.cond.0.span()),
+			// || "if condition".to_owned(),
+			// ||
+			bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?)?
+			// )?
+			{
 				evaluate(ctx, &if_else.cond_then)?
 			} else {
 				match &if_else.cond_else {
@@ -626,14 +631,13 @@
 		}
 		Slice(slice) => {
 			fn parse_idx<T: Typed + FromUntyped>(
-				loc: CallLocation<'_>,
 				ctx: Context,
 				expr: Option<&Spanned<Expr>>,
 				desc: &'static str,
 			) -> Result<Option<T>> {
 				if let Some(value) = expr {
 					Ok(in_frame(
-						loc,
+						CallLocation::new(&value.span()),
 						|| format!("slice {desc}"),
 						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),
 					)?)
@@ -643,24 +647,23 @@
 			}
 
 			let indexable = evaluate(ctx.clone(), &slice.value)?;
-			let loc = CallLocation::new(&loc);
 
-			let start = parse_idx(loc, ctx.clone(), slice.slice.start.as_ref(), "start")?;
-			let end = parse_idx(loc, ctx.clone(), slice.slice.end.as_ref(), "end")?;
-			let step = parse_idx(loc, ctx, slice.slice.step.as_ref(), "step")?;
+			let start = parse_idx(ctx.clone(), slice.slice.start.as_ref(), "start")?;
+			let end = parse_idx(ctx.clone(), slice.slice.end.as_ref(), "end")?;
+			let step = parse_idx(ctx, slice.slice.step.as_ref(), "step")?;
 
 			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?
 		}
 		Import(kind, path) => {
-			let Expr::Str(path) = &***path else {
+			let Expr::Str(path) = &**path else {
 				bail!("computed imports are not supported")
 			};
-			let tmp = loc.clone().0;
 			with_state(|s| {
-				let resolved_path = s.resolve_from(tmp.source_path(), path)?;
-				Ok(match kind {
+				let span = kind.span();
+				let resolved_path = s.resolve_from(span.0.source_path(), path)?;
+				Ok(match &**kind {
 					ImportKind::Normal => in_frame(
-						CallLocation::new(&loc),
+						CallLocation::new(&span),
 						|| format!("import {:?}", path.clone()),
 						|| s.import_resolved(resolved_path),
 					)?,
modifiedcrates/jrsonnet-evaluator/src/evaluate/operator.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -147,9 +147,9 @@
 
 pub fn evaluate_binary_op_special(
 	ctx: Context,
-	a: &Spanned<Expr>,
+	a: &Expr,
 	op: BinaryOpType,
-	b: &Spanned<Expr>,
+	b: &Expr,
 ) -> Result<Val> {
 	use BinaryOpType::*;
 	use Val::*;
modifiedcrates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -3,8 +3,8 @@
 use educe::Educe;
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
+use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
 pub use jrsonnet_macros::builtin;
-use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
 
 use self::{
 	builtin::{Builtin, StaticBuiltin},
@@ -71,7 +71,7 @@
 	/// Function parameter definition
 	pub params: ExprParams,
 	/// Function body
-	pub body: Rc<Spanned<Expr>>,
+	pub body: Rc<Expr>,
 }
 impl FuncDesc {
 	/// Create body context, but fill arguments without defaults with lazy error
@@ -256,7 +256,7 @@
 					#[cfg(feature = "exp-destruct")]
 					_ => return false,
 				};
-				**desc.body == Expr::Var(id.clone())
+				matches!(&*desc.body, Expr::Var(v) if &**v == id)
 			}
 			_ => false,
 		}
modifiedcrates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -2,7 +2,7 @@
 
 use jrsonnet_ir::{
 	function::{FunctionSignature, ParamName},
-	ArgsDesc, Expr, ExprParams, Spanned,
+	ArgsDesc, Expr, ExprParams,
 };
 use rustc_hash::FxHashMap;
 
@@ -15,7 +15,7 @@
 	Context, Pending, Thunk, Val,
 };
 
-fn eval_arg(ctx: Context, arg: &Rc<Spanned<Expr>>, tailstrict: bool) -> Result<Thunk<Val>> {
+fn eval_arg(ctx: Context, arg: &Rc<Expr>, tailstrict: bool) -> Result<Thunk<Val>> {
 	if tailstrict {
 		Ok(Thunk::evaluated(evaluate(ctx, arg)?))
 	} else {
modifiedcrates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -5,7 +5,7 @@
 extern crate self as jrsonnet_evaluator;
 
 mod arr;
-pub mod async_import;
+// pub mod async_import;
 mod ctx;
 mod dynamic;
 pub mod error;
@@ -187,7 +187,7 @@
 struct FileData {
 	string: Option<IStr>,
 	bytes: Option<IBytes>,
-	parsed: Option<Rc<Spanned<Expr>>>,
+	parsed: Option<Rc<Expr>>,
 	evaluated: Option<Val>,
 
 	evaluating: bool,
modifiedcrates/jrsonnet-ir/src/expr.rsdiffbeforeafterboth
--- a/crates/jrsonnet-ir/src/expr.rs
+++ b/crates/jrsonnet-ir/src/expr.rs
@@ -17,7 +17,7 @@
 	/// {fixed: 2}
 	Fixed(IStr),
 	/// {["dyn"+"amic"]: 3}
-	Dyn(Spanned<Expr>),
+	Dyn(Expr),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
@@ -46,7 +46,7 @@
 	pub plus: bool,
 	pub params: Option<ExprParams>,
 	pub visibility: Visibility,
-	pub value: Rc<Spanned<Expr>>,
+	pub value: Rc<Expr>,
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
@@ -152,7 +152,7 @@
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct ExprParam {
 	pub destruct: Destruct,
-	pub default: Option<Rc<Spanned<Expr>>>,
+	pub default: Option<Rc<Expr>>,
 }
 
 /// Defined function parameters
@@ -194,11 +194,11 @@
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct ArgsDesc {
-	pub unnamed: Vec<Rc<Spanned<Expr>>>,
-	pub named: Vec<(IStr, Rc<Spanned<Expr>>)>,
+	pub unnamed: Vec<Rc<Expr>>,
+	pub named: Vec<(IStr, Rc<Expr>)>,
 }
 impl ArgsDesc {
-	pub fn new(unnamed: Vec<Rc<Spanned<Expr>>>, named: Vec<(IStr, Rc<Spanned<Expr>>)>) -> Self {
+	pub fn new(unnamed: Vec<Rc<Expr>>, named: Vec<(IStr, Rc<Expr>)>) -> Self {
 		Self { unnamed, named }
 	}
 }
@@ -277,12 +277,12 @@
 pub enum BindSpec {
 	Field {
 		into: Destruct,
-		value: Rc<Spanned<Expr>>,
+		value: Rc<Expr>,
 	},
 	Function {
 		name: IStr,
 		params: ExprParams,
-		value: Rc<Spanned<Expr>>,
+		value: Rc<Expr>,
 	},
 }
 impl BindSpec {
@@ -295,15 +295,15 @@
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
-pub struct IfSpecData(pub Spanned<Expr>);
+pub struct IfSpecData(pub Expr);
 
 #[derive(Debug, PartialEq, Acyclic)]
-pub struct ForSpecData(pub Destruct, pub Spanned<Expr>);
+pub struct ForSpecData(pub Destruct, pub Expr);
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub enum CompSpec {
-	IfSpec(IfSpecData),
-	ForSpec(ForSpecData),
+	IfSpec(Spanned<IfSpecData>),
+	ForSpec(Spanned<ForSpecData>),
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
@@ -346,14 +346,14 @@
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct AssertExpr {
 	pub assert: AssertStmt,
-	pub rest: Spanned<Expr>,
+	pub rest: Expr,
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct BinaryOp {
-	pub lhs: Spanned<Expr>,
+	pub lhs: Expr,
 	pub op: BinaryOpType,
-	pub rhs: Spanned<Expr>,
+	pub rhs: Expr,
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
@@ -366,13 +366,13 @@
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct IfElse {
 	pub cond: IfSpecData,
-	pub cond_then: Spanned<Expr>,
-	pub cond_else: Option<Spanned<Expr>>,
+	pub cond_then: Expr,
+	pub cond_else: Option<Expr>,
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct Slice {
-	pub value: Spanned<Expr>,
+	pub value: Expr,
 	pub slice: SliceDesc,
 }
 
@@ -389,7 +389,7 @@
 	Var(Spanned<IStr>),
 
 	/// Array of expressions: [1, 2, "Hello"]
-	Arr(Rc<Vec<Spanned<Expr>>>),
+	Arr(Rc<Vec<Expr>>),
 	/// Array comprehension:
 	/// ```jsonnet
 	///  ingredients: [
@@ -401,35 +401,35 @@
 	///    ]
 	///  ],
 	/// ```
-	ArrComp(Rc<Spanned<Expr>>, Vec<CompSpec>),
+	ArrComp(Rc<Expr>, Vec<CompSpec>),
 
 	/// Object: {a: 2}
 	Obj(ObjBody),
 	/// Object extension: var1 {b: 2}
-	ObjExtend(Rc<Spanned<Expr>>, ObjBody),
+	ObjExtend(Rc<Expr>, ObjBody),
 
 	/// -2
-	UnaryOp(UnaryOpType, Box<Spanned<Expr>>),
+	UnaryOp(UnaryOpType, Box<Expr>),
 	/// 2 - 2
 	BinaryOp(Box<BinaryOp>),
 	/// assert 2 == 2 : "Math is broken"
 	AssertExpr(Rc<AssertExpr>),
 	/// local a = 2; { b: a }
-	LocalExpr(Vec<BindSpec>, Box<Spanned<Expr>>),
+	LocalExpr(Vec<BindSpec>, Box<Expr>),
 
 	/// import* "hello"
-	Import(ImportKind, Box<Spanned<Expr>>),
+	Import(Spanned<ImportKind>, Box<Expr>),
 	/// error "I'm broken"
-	ErrorStmt(Box<Spanned<Expr>>),
+	ErrorStmt(Span, Box<Expr>),
 	/// a(b, c)
-	Apply(Box<Spanned<Expr>>, Spanned<ArgsDesc>, bool),
+	Apply(Box<Expr>, Spanned<ArgsDesc>, bool),
 	/// a[b], a.b, a?.b
 	Index {
-		indexable: Box<Spanned<Expr>>,
+		indexable: Box<Expr>,
 		parts: Vec<IndexPart>,
 	},
 	/// function(x) x
-	Function(ExprParams, Rc<Spanned<Expr>>),
+	Function(ExprParams, Rc<Expr>),
 	/// if true == false then 1 else 2
 	IfElse(Box<IfElse>),
 	Slice(Box<Slice>),
@@ -437,7 +437,8 @@
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct IndexPart {
-	pub value: Spanned<Expr>,
+	pub span: Span,
+	pub value: Expr,
 	#[cfg(feature = "exp-null-coaelse")]
 	pub null_coaelse: bool,
 }
@@ -461,7 +462,7 @@
 }
 
 #[derive(Clone, PartialEq, Acyclic)]
-pub struct Spanned<T: Acyclic>(T, Span);
+pub struct Spanned<T: Acyclic>(pub T, pub Span);
 impl<T: Acyclic> Deref for Spanned<T> {
 	type Target = T;
 	fn deref(&self) -> &Self::Target {
modifiedcrates/jrsonnet-peg-parser/Cargo.tomldiffbeforeafterboth
--- a/crates/jrsonnet-peg-parser/Cargo.toml
+++ b/crates/jrsonnet-peg-parser/Cargo.toml
@@ -7,6 +7,7 @@
 version.workspace = true
 
 [dependencies]
+jrsonnet-gcmodule.workspace = true
 jrsonnet-ir.workspace = true
 peg.workspace = true
modifiedcrates/jrsonnet-peg-parser/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -1,7 +1,9 @@
+use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_ir::{
-	BinaryOp, Expr, ExprParams, IStr, IndexPart, Member, Slice, SliceDesc, Source, Span, Spanned,
-	ExprParam, ArgsDesc, AssertExpr, ImportKind, LiteralType, IfElse, CompSpec, ForSpecData, IfSpecData, ObjMembers, ObjBody,
-	ObjComp, FieldMember, Visibility, FieldName, unescape, AssertStmt, BindSpec, Destruct, DestructRest,
+	unescape, ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BindSpec, CompSpec, Destruct,
+	DestructRest, Expr, ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse,
+	IfSpecData, ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice,
+	SliceDesc, Source, Span, Spanned, Visibility,
 };
 use peg::parser;
 use std::rc::Rc;
@@ -63,7 +65,7 @@
 			= params:param(s) ** comma() comma()? { ExprParams::new(params) }
 			/ { ExprParams::new(Vec::new()) }
 
-		pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Spanned<Expr>>)
+		pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Expr>)
 			= name:(quiet! { (s:id() _ "=" !['='] _ {s})? } / expected!("<argument name>")) expr:expr(s) {(name, Rc::new(expr))}
 
 		pub rule args(s: &ParserSettings) -> ArgsDesc
@@ -133,7 +135,7 @@
 			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {BindSpec::Function{name, params, value: Rc::new(value)}}
 
 		pub rule assertion(s: &ParserSettings) -> AssertStmt
-			= keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { AssertStmt(cond, msg) }
+			= keyword("assert") _ cond:spanned(<expr(s)>, s) msg:(_ ":" _ e:spanned(<expr(s)>, s) {e})? { AssertStmt(cond, msg) }
 
 		pub rule whole_line() -> &'input str
 			= str:$((!['\n'][_])* "\n") {str}
@@ -241,7 +243,7 @@
 		pub rule forspec(s: &ParserSettings) -> ForSpecData
 			= keyword("for") _ id:destruct(s) _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}
 		rule compspec(s: &ParserSettings) -> CompSpec
-			= i:ifspec(s) { CompSpec::IfSpec(i) } / f:forspec(s) {CompSpec::ForSpec(f)}
+			= i:spanned(<ifspec(s)>, s) { CompSpec::IfSpec(i) } / f:spanned(<forspec(s)>, s) {CompSpec::ForSpec(f)}
 		pub rule compspecs(s: &ParserSettings) -> Vec<CompSpec>
 			= specs:compspec(s) ++ _ {?
 				if !matches!(specs[0], CompSpec::ForSpec(_)) {
@@ -267,8 +269,12 @@
 			} else {
 				Err("!!!numbers are finite")
 			}}
+
+		rule spanned<T: Acyclic>(x: rule<T>, s: &ParserSettings) -> Spanned<T>
+			= a:position!() n:x() b:position!() { Spanned::new(n, Span(s.source.clone(), a as u32, b as u32)) }
+
 		pub rule var_expr(s: &ParserSettings) -> Expr
-			= n:id() { Expr::Var(n) }
+			= n:spanned(<id()>, s) { Expr::Var(n) }
 		pub rule id_loc(s: &ParserSettings) -> Spanned<Expr>
 			= a:position!() n:id() b:position!() { Spanned::new(Expr::Str(n), Span(s.source.clone(), a as u32,b as u32)) }
 		pub rule if_then_else_expr(s: &ParserSettings) -> Expr
@@ -302,7 +308,7 @@
 			/ array_expr(s)
 			/ array_comp_expr(s)
 
-			/ kind:import_kind() _ path:expr(s) {Expr::Import(kind, Box::new(path))}
+			/ kind:spanned(<import_kind()>, s) _ path:expr(s) {Expr::Import(kind, Box::new(path))}
 
 			/ var_expr(s)
 			/ local_expr(s)
@@ -313,10 +319,10 @@
 				assert, rest
 			})) }
 
-			/ keyword("error") _ expr:expr(s) { Expr::ErrorStmt(Box::new(expr)) }
+			/ err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.1, Box::new(expr)) }
 
 		rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>
-			= _ e:(e:expr(s) _{e})? {e}
+			= _ e:(e:spanned(<expr(s)>, s) _{e})? {e}
 		pub rule slice_desc(s: &ParserSettings) -> SliceDesc
 			= start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {
 				let (end, step) = if let Some((end, step)) = pair {
@@ -340,11 +346,8 @@
 			}
 		use jrsonnet_ir::BinaryOpType::*;
 		use jrsonnet_ir::UnaryOpType::*;
-		rule expr(s: &ParserSettings) -> Spanned<Expr>
+		rule expr(s: &ParserSettings) -> Expr
 			= precedence! {
-				"(" _ e:expr(s) _ ")" {e}
-				start:position!() v:@ end:position!() { Spanned::new(v, Span(s.source.clone(), start as u32, end as u32)) }
-				--
 				a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}
 				a:(@) _ binop(<"??">) _ ensure_null_coaelse() b:@ {
 					#[cfg(feature = "exp-null-coaelse")] return expr_bin!(a NullCoaelse b);
@@ -385,29 +388,32 @@
 				--
 				value:(@) _ "[" _ slice:slice_desc(s) _ "]" {Expr::Slice(Box::new(Slice{value, slice}))}
 				indexable:(@) _ parts:index_part(s)+ {Expr::Index{indexable: Box::new(indexable), parts}}
-				a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(Box::new(a), args, ts.is_some())}
+				a:(@) _ args:spanned(<"(" _ a:args(s) _ ")" {a}>, s) ts:(_ keyword("tailstrict"))? {Expr::Apply(Box::new(a), args, ts.is_some())}
 				a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(Rc::new(a), body)}
 				--
 				e:expr_basic(s) {e}
+				"(" _ e:expr(s) _ ")" {e}
 			}
 		pub rule index_part(s: &ParserSettings) -> IndexPart
 		= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {
-			value,
+			span: value.1,
+			value: value.0,
 			#[cfg(feature = "exp-null-coaelse")]
 			null_coaelse: n.is_some(),
 		}}
-		/ n:("?" _ "." _ ensure_null_coaelse())? "[" _ value:expr(s) _ "]" {IndexPart {
-			value,
+		/ n:("?" _ "." _ ensure_null_coaelse())? value:spanned(<"[" _ v:expr(s) _ "]" {v}>, s) {IndexPart {
+			span: value.1,
+			value: value.0,
 			#[cfg(feature = "exp-null-coaelse")]
 			null_coaelse: n.is_some(),
 		}}
 
-		pub rule jsonnet(s: &ParserSettings) -> Spanned<Expr> = _ e:expr(s) _ {e}
+		pub rule jsonnet(s: &ParserSettings) -> Expr = _ e:expr(s) _ {e}
 	}
 }
 
 pub type ParseError = peg::error::ParseError<peg::str::LineCol>;
-pub fn parse(str: &str, settings: &ParserSettings) -> Result<Spanned<Expr>, ParseError> {
+pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr, ParseError> {
 	jsonnet_parser::jsonnet(str, settings)
 }
 /// Used for importstr values