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

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -4,34 +4,15 @@
 use jrsonnet_interner::IStr;
 
 use crate::{
-	cc_ptr_eq, error::Error::*, gc::GcHashMap, map::LayeredHashMap, LazyBinding, ObjValue, Pending,
-	Result, State, Thunk, Val,
+	cc_ptr_eq, error::Error::*, gc::GcHashMap, map::LayeredHashMap, ObjValue, Pending, Result,
+	Thunk, Val,
 };
 
-#[derive(Clone, Trace)]
-pub struct ContextCreator(pub Context, pub Pending<GcHashMap<IStr, LazyBinding>>);
-impl ContextCreator {
-	pub fn create(
-		&self,
-		s: State,
-		this: Option<ObjValue>,
-		super_obj: Option<ObjValue>,
-	) -> Result<Context> {
-		self.0.clone().extend_unbound(
-			s,
-			self.1.clone().unwrap(),
-			self.0.dollar().clone().or_else(|| this.clone()),
-			this,
-			super_obj,
-		)
-	}
-}
-
 #[derive(Trace)]
 struct ContextInternals {
 	dollar: Option<ObjValue>,
+	sup: Option<ObjValue>,
 	this: Option<ObjValue>,
-	super_obj: Option<ObjValue>,
 	bindings: LayeredHashMap,
 }
 impl Debug for ContextInternals {
@@ -56,14 +37,14 @@
 	}
 
 	pub fn super_obj(&self) -> &Option<ObjValue> {
-		&self.0.super_obj
+		&self.0.sup
 	}
 
 	pub fn new() -> Self {
 		Self(Cc::new(ContextInternals {
 			dollar: None,
 			this: None,
-			super_obj: None,
+			sup: None,
 			bindings: LayeredHashMap::default(),
 		}))
 	}
@@ -92,11 +73,6 @@
 		let mut new_bindings = GcHashMap::with_capacity(1);
 		new_bindings.insert(name, Thunk::evaluated(value));
 		self.extend(new_bindings, None, None, None)
-	}
-
-	#[must_use]
-	pub fn with_this_super(self, new_this: ObjValue, new_super_obj: Option<ObjValue>) -> Self {
-		self.extend(GcHashMap::new(), None, Some(new_this), new_super_obj)
 	}
 
 	#[must_use]
@@ -104,13 +80,13 @@
 		self,
 		new_bindings: GcHashMap<IStr, Thunk<Val>>,
 		new_dollar: Option<ObjValue>,
+		new_sup: Option<ObjValue>,
 		new_this: Option<ObjValue>,
-		new_super_obj: Option<ObjValue>,
 	) -> Self {
 		let ctx = &self.0;
 		let dollar = new_dollar.or_else(|| ctx.dollar.clone());
 		let this = new_this.or_else(|| ctx.this.clone());
-		let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());
+		let sup = new_sup.or_else(|| ctx.sup.clone());
 		let bindings = if new_bindings.is_empty() {
 			ctx.bindings.clone()
 		} else {
@@ -118,32 +94,10 @@
 		};
 		Self(Cc::new(ContextInternals {
 			dollar,
+			sup,
 			this,
-			super_obj,
 			bindings,
 		}))
-	}
-	#[must_use]
-	pub fn extend_bound(self, new_bindings: GcHashMap<IStr, Thunk<Val>>) -> Self {
-		let new_this = self.0.this.clone();
-		let new_super_obj = self.0.super_obj.clone();
-		self.extend(new_bindings, None, new_this, new_super_obj)
-	}
-	pub fn extend_unbound(
-		self,
-		s: State,
-		new_bindings: GcHashMap<IStr, LazyBinding>,
-		new_dollar: Option<ObjValue>,
-		new_this: Option<ObjValue>,
-		new_super_obj: Option<ObjValue>,
-	) -> Result<Self> {
-		let this = new_this.or_else(|| self.0.this.clone());
-		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());
-		let mut new = GcHashMap::with_capacity(new_bindings.len());
-		for (k, v) in new_bindings.0 {
-			new.insert(k, v.evaluate(s.clone(), this.clone(), super_obj.clone())?);
-		}
-		Ok(self.extend(new, new_dollar, this, super_obj))
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -11,12 +11,13 @@
 	Context, Pending, State, Thunk, Val,
 };
 
+#[allow(clippy::too_many_lines)]
 fn destruct(
 	d: &Destruct,
 	parent: Thunk<Val>,
 	new_bindings: &mut GcHashMap<IStr, Thunk<Val>>,
 ) -> Result<()> {
-	Ok(match d {
+	match d {
 		Destruct::Full(v) => {
 			let old = new_bindings.insert(v.clone(), parent);
 			if old.is_some() {
@@ -157,8 +158,6 @@
 		}
 		#[cfg(feature = "exp-destruct")]
 		Destruct::Object { fields, rest } => {
-			use jrsonnet_parser::DestructRest;
-
 			use crate::{obj::ObjValue, throw_runtime};
 
 			#[derive(Trace)]
@@ -223,7 +222,8 @@
 				}
 			}
 		}
-	})
+	}
+	Ok(())
 }
 
 pub fn evaluate_dest(

1use std::rc::Rc;
2
1use gcmodule::{Cc, Trace};3use gcmodule::{Cc, Trace};
2use jrsonnet_interner::IStr;4use jrsonnet_interner::IStr;
3use jrsonnet_parser::{5use jrsonnet_parser::{
4	ArgsDesc, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, ForSpecData, IfSpecData,6	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, ForSpecData, IfSpecData,
5	LiteralType, LocExpr, Member, ObjBody, ParamsDesc,7	LiteralType, LocExpr, Member, ObjBody, ParamsDesc,
6};8};
7use jrsonnet_types::ValType;9use jrsonnet_types::ValType;
14	stdlib::{std_slice, BUILTINS},16	stdlib::{std_slice, BUILTINS},
15	tb, throw,17	tb, throw,
16	typed::Typed,18	typed::Typed,
17	val::{ArrValue, Thunk, ThunkValue},19	val::{ArrValue, CachedBindable, Thunk, ThunkValue},
18	Bindable, Context, ContextCreator, GcHashMap, LazyBinding, ObjValue, ObjValueBuilder,20	Bindable, Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,
19	ObjectAssertion, Pending, Result, State, Val,21	State, Val,
20};22};
21pub mod destructure;23pub mod destructure;
22pub mod operator;24pub mod operator;
23
24#[allow(clippy::too_many_lines)]
25pub fn evaluate_binding(b: BindSpec, cctx: ContextCreator) -> Result<(IStr, LazyBinding)> {
26	match b {
27		BindSpec::Field {
28			into: Destruct::Full(name),
29			value,
30		} => {
31			#[derive(Trace)]
32			struct BindableNamedThunk {
33				this: Option<ObjValue>,
34				super_obj: Option<ObjValue>,
35
36				cctx: ContextCreator,
37				name: IStr,
38				value: LocExpr,
39			}
40			impl ThunkValue for BindableNamedThunk {
41				type Output = Val;
42				fn get(self: Box<Self>, s: State) -> Result<Val> {
43					evaluate_named(
44						s.clone(),
45						self.cctx.create(s, self.this, self.super_obj)?,
46						&self.value,
47						self.name,
48					)
49				}
50			}
51
52			#[derive(Trace)]
53			struct BindableNamed {
54				cctx: ContextCreator,
55				name: IStr,
56				value: LocExpr,
57			}
58			impl Bindable for BindableNamed {
59				fn bind(
60					&self,
61					_: State,
62					this: Option<ObjValue>,
63					super_obj: Option<ObjValue>,
64				) -> Result<Thunk<Val>> {
65					Ok(Thunk::new(tb!(BindableNamedThunk {
66						this,
67						super_obj,
68
69						cctx: self.cctx.clone(),
70						name: self.name.clone(),
71						value: self.value.clone(),
72					})))
73				}
74			}
75
76			Ok((
77				name.clone(),
78				LazyBinding::Bindable(Cc::new(tb!(BindableNamed {
79					cctx,
80					name: name.clone(),
81					value: value.clone(),
82				}))),
83			))
84		}
85		#[cfg(feature = "exp-destruct")]
86		BindSpec::Field { into: _, .. } => {
87			use crate::throw_runtime;
88			throw_runtime!("destructuring is not yet supported here")
89		}
90		BindSpec::Function {
91			name,
92			params,
93			value,
94		} => {
95			#[derive(Trace)]
96			struct BindableMethodThunk {
97				this: Option<ObjValue>,
98				super_obj: Option<ObjValue>,
99
100				cctx: ContextCreator,
101				name: IStr,
102				params: ParamsDesc,
103				value: LocExpr,
104			}
105			impl ThunkValue for BindableMethodThunk {
106				type Output = Val;
107				fn get(self: Box<Self>, s: State) -> Result<Val> {
108					Ok(evaluate_method(
109						self.cctx.create(s, self.this, self.super_obj)?,
110						self.name,
111						self.params,
112						self.value,
113					))
114				}
115			}
116
117			#[derive(Trace)]
118			struct BindableMethod {
119				cctx: ContextCreator,
120				name: IStr,
121				params: ParamsDesc,
122				value: LocExpr,
123			}
124			impl Bindable for BindableMethod {
125				fn bind(
126					&self,
127					_: State,
128					this: Option<ObjValue>,
129					super_obj: Option<ObjValue>,
130				) -> Result<Thunk<Val>> {
131					Ok(Thunk::<Val>::new(tb!(BindableMethodThunk {
132						this,
133						super_obj,
134
135						cctx: self.cctx.clone(),
136						name: self.name.clone(),
137						params: self.params.clone(),
138						value: self.value.clone(),
139					})))
140				}
141			}
142
143			let params = params.clone();
144
145			Ok((
146				name.clone(),
147				LazyBinding::Bindable(Cc::new(tb!(BindableMethod {
148					cctx,
149					name: name.clone(),
150					params,
151					value,
152				}))),
153			))
154		}
155	}
156}
15725
158pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {26pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
159	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {27	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
218	Ok(())86	Ok(())
219}87}
88
89trait CloneableBindable<T>: Bindable<Bound = T> + Clone {}
90
91fn evaluate_object_locals(
92	fctx: Pending<Context>,
93	locals: Rc<Vec<BindSpec>>,
94) -> impl CloneableBindable<Context> {
95	#[derive(Trace, Clone)]
96	struct WithObjectLocals {
97		fctx: Pending<Context>,
98		locals: Rc<Vec<BindSpec>>,
99	}
100	impl CloneableBindable<Context> for WithObjectLocals {}
101	impl Bindable for WithObjectLocals {
102		type Bound = Context;
103
104		fn bind(
105			&self,
106			_s: State,
107			sup: Option<ObjValue>,
108			this: Option<ObjValue>,
109		) -> Result<Context> {
110			let fctx = Context::new_future();
111			let mut new_bindings = GcHashMap::new();
112			for b in self.locals.iter() {
113				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
114			}
115
116			let ctx = self.fctx.unwrap();
117			let new_dollar = ctx.dollar().clone().or_else(|| this.clone());
118
119			let ctx = ctx
120				.extend(new_bindings, new_dollar, sup, this)
121				.into_future(fctx);
122
123			Ok(ctx)
124		}
125	}
126
127	WithObjectLocals { fctx, locals }
128}
220129
221#[allow(clippy::too_many_lines)]130#[allow(clippy::too_many_lines)]
222pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {131pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {
223	let new_bindings = Pending::new();132	let mut builder = ObjValueBuilder::new();
224	let future_this = Pending::new();
225	let cctx = ContextCreator(ctx.clone(), new_bindings.clone());
226	{
227		let mut bindings: GcHashMap<IStr, LazyBinding> = GcHashMap::with_capacity(members.len());133	let locals = Rc::new(
228		for r in members134		members
229			.iter()135			.iter()
230			.filter_map(|m| match m {136			.filter_map(|m| match m {
231				Member::BindStmt(b) => Some(b.clone()),137				Member::BindStmt(bind) => Some(bind.clone()),
232				_ => None,138				_ => None,
233			})139			})
234			.map(|b| evaluate_binding(b.clone(), cctx.clone()))140			.collect::<Vec<_>>(),
235		{141	);
236			let (n, b) = r?;142
237			bindings.insert(n, b);
238		}
239		new_bindings.fill(bindings);143	let fctx = Context::new_future();
240	}144
241145	// We have single context for all fields, so we can cache binds
242	let mut builder = ObjValueBuilder::new();146	let uctx = CachedBindable::new(evaluate_object_locals(fctx.clone(), locals));
147
243	for member in members.iter() {148	for member in members.iter() {
244		match member {149		match member {
250				value,155				value,
251			}) => {156			}) => {
252				#[derive(Trace)]157				#[derive(Trace)]
253				struct ObjMemberBinding {158				struct ObjMemberBinding<B> {
254					cctx: ContextCreator,159					uctx: B,
255					value: LocExpr,160					value: LocExpr,
256					name: IStr,161					name: IStr,
257				}162				}
258				impl Bindable for ObjMemberBinding {163				impl<B: Bindable<Bound = Context>> Bindable for ObjMemberBinding<B> {
164					type Bound = Thunk<Val>;
259					fn bind(165					fn bind(
260						&self,166						&self,
261						s: State,167						s: State,
262						this: Option<ObjValue>,168						sup: Option<ObjValue>,
263						super_obj: Option<ObjValue>,169						this: Option<ObjValue>,
264					) -> Result<Thunk<Val>> {170					) -> Result<Thunk<Val>> {
265						Ok(Thunk::evaluated(evaluate_named(171						Ok(Thunk::evaluated(evaluate_named(
266							s.clone(),172							s.clone(),
267							self.cctx.create(s, this, super_obj)?,173							self.uctx.bind(s, sup, this)?,
268							&self.value,174							&self.value,
269							self.name.clone(),175							self.name.clone(),
270						)?))176						)?))
286					.bindable(192					.bindable(
287						s.clone(),193						s.clone(),
288						tb!(ObjMemberBinding {194						tb!(ObjMemberBinding {
289							cctx: cctx.clone(),195							uctx: uctx.clone(),
290							value: value.clone(),196							value: value.clone(),
291							name,197							name: name.clone()
292						}),198						}),
293					)?;199					)?;
294			}200			}
299				..205				..
300			}) => {206			}) => {
301				#[derive(Trace)]207				#[derive(Trace)]
302				struct ObjMemberBinding {208				struct ObjMemberBinding<B> {
303					cctx: ContextCreator,209					uctx: B,
304					value: LocExpr,210					value: LocExpr,
305					params: ParamsDesc,211					params: ParamsDesc,
306					name: IStr,212					name: IStr,
307				}213				}
308				impl Bindable for ObjMemberBinding {214				impl<B: Bindable<Bound = Context>> Bindable for ObjMemberBinding<B> {
215					type Bound = Thunk<Val>;
309					fn bind(216					fn bind(
310						&self,217						&self,
311						s: State,218						s: State,
312						this: Option<ObjValue>,219						sup: Option<ObjValue>,
313						super_obj: Option<ObjValue>,220						this: Option<ObjValue>,
314					) -> Result<Thunk<Val>> {221					) -> Result<Thunk<Val>> {
315						Ok(Thunk::evaluated(evaluate_method(222						Ok(Thunk::evaluated(evaluate_method(
316							self.cctx.create(s, this, super_obj)?,223							self.uctx.bind(s, sup, this)?,
317							self.name.clone(),224							self.name.clone(),
318							self.params.clone(),225							self.params.clone(),
319							self.value.clone(),226							self.value.clone(),
334					.bindable(241					.bindable(
335						s.clone(),242						s.clone(),
336						tb!(ObjMemberBinding {243						tb!(ObjMemberBinding {
337							cctx: cctx.clone(),244							uctx: uctx.clone(),
338							value: value.clone(),245							value: value.clone(),
339							params: params.clone(),246							params: params.clone(),
340							name,247							name: name.clone()
341						}),248						}),
342					)?;249					)?;
343			}250			}
344			Member::BindStmt(_) => {}251			Member::BindStmt(_) => {}
345			Member::AssertStmt(stmt) => {252			Member::AssertStmt(stmt) => {
346				#[derive(Trace)]253				#[derive(Trace)]
347				struct ObjectAssert {254				struct ObjectAssert<B> {
348					cctx: ContextCreator,255					uctx: B,
349					assert: AssertStmt,256					assert: AssertStmt,
350				}257				}
351				impl ObjectAssertion for ObjectAssert {258				impl<B: Bindable<Bound = Context>> ObjectAssertion for ObjectAssert<B> {
352					fn run(259					fn run(
353						&self,260						&self,
354						s: State,261						s: State,
355						this: Option<ObjValue>,262						sup: Option<ObjValue>,
356						super_obj: Option<ObjValue>,263						this: Option<ObjValue>,
357					) -> Result<()> {264					) -> Result<()> {
358						let ctx = self.cctx.create(s.clone(), this, super_obj)?;265						let ctx = self.uctx.bind(s.clone(), sup, this)?;
359						evaluate_assert(s, ctx, &self.assert)266						evaluate_assert(s, ctx, &self.assert)
360					}267					}
361				}268				}
362				builder.assert(tb!(ObjectAssert {269				builder.assert(tb!(ObjectAssert {
363					cctx: cctx.clone(),270					uctx: uctx.clone(),
364					assert: stmt.clone(),271					assert: stmt.clone(),
365				}));272				}));
366			}273			}
367		}274		}
368	}275	}
369	let this = builder.build();276	let this = builder.build();
277	let _ctx = ctx
370	future_this.fill(this.clone());278		.extend(GcHashMap::new(), None, None, Some(this.clone()))
279		.into_future(fctx);
371	Ok(this)280	Ok(this)
372}281}
373282
374pub fn evaluate_object(s: State, ctx: Context, object: &ObjBody) -> Result<ObjValue> {283pub fn evaluate_object(s: State, ctx: Context, object: &ObjBody) -> Result<ObjValue> {
375	Ok(match object {284	Ok(match object {
376		ObjBody::MemberList(members) => evaluate_member_list_object(s, ctx, members)?,285		ObjBody::MemberList(members) => evaluate_member_list_object(s, ctx, members)?,
377		ObjBody::ObjComp(obj) => {286		ObjBody::ObjComp(obj) => {
378			let future_this = Pending::new();287			let mut builder = ObjValueBuilder::new();
379			let mut builder = ObjValueBuilder::new();288			let locals = Rc::new(
289				obj.pre_locals
290					.iter()
291					.chain(obj.post_locals.iter())
292					.cloned()
293					.collect::<Vec<_>>(),
294			);
295			let mut ctxs = vec![];
380			evaluate_comp(s.clone(), ctx, &obj.compspecs, &mut |ctx| {296			evaluate_comp(s.clone(), ctx, &obj.compspecs, &mut |ctx| {
381				let new_bindings = Pending::new();
382				let cctx = ContextCreator(ctx.clone(), new_bindings.clone());297				let key = evaluate(s.clone(), ctx.clone(), &obj.key)?;
383				let mut bindings: GcHashMap<IStr, LazyBinding> =298				let fctx = Context::new_future();
384					GcHashMap::with_capacity(obj.pre_locals.len() + obj.post_locals.len());
385				for r in obj
386					.pre_locals
387					.iter()
388					.chain(obj.post_locals.iter())
389					.map(|b| evaluate_binding(b.clone(), cctx.clone()))299				ctxs.push((ctx, fctx.clone()));
390				{
391					let (n, b) = r?;
392					bindings.insert(n, b);
393				}
394				new_bindings.fill(bindings.clone());
395				let ctx = ctx.extend_unbound(s.clone(), bindings, None, None, None)?;
396				let key = evaluate(s.clone(), ctx.clone(), &obj.key)?;300				let uctx = evaluate_object_locals(fctx, locals.clone());
397301
398				match key {302				match key {
399					Val::Null => {}303					Val::Null => {}
400					Val::Str(n) => {304					Val::Str(n) => {
401						#[derive(Trace)]305						#[derive(Trace)]
402						struct ObjCompBinding {306						struct ObjCompBinding<B> {
403							ctx: Context,307							uctx: B,
404							value: LocExpr,308							value: LocExpr,
405						}309						}
406						impl Bindable for ObjCompBinding {310						impl<B: Bindable<Bound = Context>> Bindable for ObjCompBinding<B> {
311							type Bound = Thunk<Val>;
407							fn bind(312							fn bind(
408								&self,313								&self,
409								s: State,314								s: State,
410								this: Option<ObjValue>,315								sup: Option<ObjValue>,
411								_super_obj: Option<ObjValue>,316								this: Option<ObjValue>,
412							) -> Result<Thunk<Val>> {317							) -> Result<Thunk<Val>> {
413								Ok(Thunk::evaluated(evaluate(318								Ok(Thunk::evaluated(evaluate(
414									s,319									s.clone(),
415									self.ctx.clone().extend(GcHashMap::new(), None, this, None),320									self.uctx.bind(s, sup, this.clone())?.extend(
321										GcHashMap::new(),
322										None,
323										None,
324										this,
325									),
416									&self.value,326									&self.value,
424							.bindable(334							.bindable(
425								s.clone(),335								s.clone(),
426								tb!(ObjCompBinding {336								tb!(ObjCompBinding {
427									ctx,337									uctx,
428									value: obj.value.clone(),338									value: obj.value.clone(),
429								}),339								}),
430							)?;340							)?;
436			})?;346			})?;
437347
438			let this = builder.build();348			let this = builder.build();
349			for (ctx, fctx) in ctxs {
350				let _ctx = ctx
439			future_this.fill(this.clone());351					.extend(GcHashMap::new(), None, None, Some(this.clone()))
352					.into_future(fctx);
353			}
440			this354			this
441		}355		}
442	})356	})
596			for b in bindings {510			for b in bindings {
597				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;511				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
598			}512			}
599			let ctx = ctx.extend_bound(new_bindings).into_future(fctx);513			let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);
600			evaluate(s, ctx, &returned.clone())?514			evaluate(s, ctx, &returned.clone())?
601		}515		}
602		Arr(items) => {516		Arr(items) => {

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -139,11 +139,12 @@
 	) -> Result<Val> {
 		match self {
 			Self::Id => {
+				#[allow(clippy::unnecessary_wraps)]
 				#[builtin]
-				fn builtin_id(v: Any) -> Result<Any> {
+				const fn builtin_id(v: Any) -> Result<Any> {
 					Ok(v)
 				}
-				static ID: &'static builtin_id = &builtin_id {};
+				static ID: &builtin_id = &builtin_id {};
 
 				ID.call(s, call_ctx, loc, args)
 			}
@@ -159,10 +160,10 @@
 		self.evaluate(s, Context::default(), CallLocation::native(), args, true)
 	}
 
-	pub fn is_identity(&self) -> bool {
+	pub const fn is_identity(&self) -> bool {
 		matches!(self, Self::Id)
 	}
-	pub fn identity() -> Self {
+	pub const fn identity() -> Self {
 		Self::Id
 	}
 }

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -111,7 +111,7 @@
 
 		Ok(body_ctx
 			.extend(passed_args, None, None, None)
-			.extend_bound(defaults)
+			.extend(defaults, None, None, None)
 			.into_future(fctx))
 	} else {
 		let body_ctx = body_ctx.extend(passed_args, None, None, None);

--- a/crates/jrsonnet-evaluator/src/gc.rs
+++ b/crates/jrsonnet-evaluator/src/gc.rs
@@ -10,7 +10,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 
 /// Replacement for box, which assumes that the underlying type is [`Trace`]
-/// Used in places, where Cc<dyn Trait> should be used instead, but it can't, because CoerceUnsiced is not stable
+/// Used in places, where `Cc<dyn Trait>` should be used instead, but it can't, because `CoerceUnsiced` is not stable
 #[derive(Debug, Clone)]
 pub struct TraceBox<T: ?Sized>(pub Box<T>);
 #[macro_export]

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -61,17 +61,13 @@
 pub use val::{ManifestFormat, Thunk, Val};
 
 pub trait Bindable: Trace + 'static {
-	fn bind(
-		&self,
-		s: State,
-		this: Option<ObjValue>,
-		super_obj: Option<ObjValue>,
-	) -> Result<Thunk<Val>>;
+	type Bound;
+	fn bind(&self, s: State, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;
 }
 
 #[derive(Clone, Trace)]
 pub enum LazyBinding {
-	Bindable(Cc<TraceBox<dyn Bindable>>),
+	Bindable(Cc<TraceBox<dyn Bindable<Bound = Thunk<Val>>>>),
 	Bound(Thunk<Val>),
 }
 
@@ -84,11 +80,11 @@
 	pub fn evaluate(
 		&self,
 		s: State,
+		sup: Option<ObjValue>,
 		this: Option<ObjValue>,
-		super_obj: Option<ObjValue>,
 	) -> Result<Thunk<Val>> {
 		match self {
-			Self::Bindable(v) => v.bind(s, this, super_obj),
+			Self::Bindable(v) => v.bind(s, sup, this),
 			Self::Bound(v) => Ok(v.clone()),
 		}
 	}
@@ -345,7 +341,7 @@
 		for (name, value) in globals.iter() {
 			new_bindings.insert(name.clone(), Thunk::evaluated(value.clone()));
 		}
-		Context::new().extend_bound(new_bindings)
+		Context::new().extend(new_bindings, None, None, None)
 	}
 
 	/// Executes code creating a new stack frame

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -106,7 +106,7 @@
 }
 
 pub trait ObjectAssertion: Trace {
-	fn run(&self, s: State, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<()>;
+	fn run(&self, s: State, super_obj: Option<ObjValue>, this: Option<ObjValue>) -> Result<()>;
 }
 
 // Field => This
@@ -124,10 +124,11 @@
 #[derive(Trace)]
 #[force_tracking]
 pub struct ObjValueInternals {
-	super_obj: Option<ObjValue>,
+	sup: Option<ObjValue>,
+	this: Option<ObjValue>,
+
 	assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,
 	assertions_ran: RefCell<GcHashSet<ObjValue>>,
-	this_obj: Option<ObjValue>,
 	this_entries: Cc<GcHashMap<IStr, ObjMember>>,
 	value_cache: RefCell<GcHashMap<CacheKey, CacheValue>>,
 }
@@ -153,7 +154,7 @@
 pub struct ObjValue(pub(crate) Cc<ObjValueInternals>);
 impl Debug for ObjValue {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		if let Some(super_obj) = self.0.super_obj.as_ref() {
+		if let Some(super_obj) = self.0.sup.as_ref() {
 			if f.alternate() {
 				write!(f, "{:#?}", super_obj)?;
 			} else {
@@ -171,15 +172,15 @@
 
 impl ObjValue {
 	pub fn new(
-		super_obj: Option<Self>,
+		sup: Option<Self>,
 		this_entries: Cc<GcHashMap<IStr, ObjMember>>,
 		assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,
 	) -> Self {
 		Self(Cc::new(ObjValueInternals {
-			super_obj,
+			sup,
+			this: None,
 			assertions,
 			assertions_ran: RefCell::new(GcHashSet::new()),
-			this_obj: None,
 			this_entries,
 			value_cache: RefCell::new(GcHashMap::new()),
 		}))
@@ -188,15 +189,15 @@
 		Self::new(None, Cc::new(GcHashMap::new()), Cc::new(Vec::new()))
 	}
 	#[must_use]
-	pub fn extend_from(&self, super_obj: Self) -> Self {
-		match &self.0.super_obj {
+	pub fn extend_from(&self, sup: Self) -> Self {
+		match &self.0.sup {
 			None => Self::new(
-				Some(super_obj),
+				Some(sup),
 				self.0.this_entries.clone(),
 				self.0.assertions.clone(),
 			),
 			Some(v) => Self::new(
-				Some(v.extend_from(super_obj)),
+				Some(v.extend_from(sup)),
 				self.0.this_entries.clone(),
 				self.0.assertions.clone(),
 			),
@@ -212,12 +213,12 @@
 	}
 
 	#[must_use]
-	pub fn with_this(&self, this_obj: Self) -> Self {
+	pub fn with_this(&self, this: Self) -> Self {
 		Self(Cc::new(ObjValueInternals {
-			super_obj: self.0.super_obj.clone(),
+			sup: self.0.sup.clone(),
 			assertions: self.0.assertions.clone(),
 			assertions_ran: RefCell::new(GcHashSet::new()),
-			this_obj: Some(this_obj),
+			this: Some(this),
 			this_entries: self.0.this_entries.clone(),
 			value_cache: RefCell::new(GcHashMap::new()),
 		}))
@@ -234,7 +235,7 @@
 		if !self.0.this_entries.is_empty() {
 			return false;
 		}
-		self.0.super_obj.as_ref().map_or(true, Self::is_empty)
+		self.0.sup.as_ref().map_or(true, Self::is_empty)
 	}
 
 	/// Run callback for every field found in object
@@ -243,7 +244,7 @@
 		depth: SuperDepth,
 		handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,
 	) -> bool {
-		if let Some(s) = &self.0.super_obj {
+		if let Some(s) = &self.0.sup {
 			if s.enum_fields(depth.deeper(), handler) {
 				return true;
 			}
@@ -332,13 +333,13 @@
 			Some(match &m.visibility {
 				Visibility::Normal => self
 					.0
-					.super_obj
+					.sup
 					.as_ref()
 					.and_then(|super_obj| super_obj.field_visibility(name))
 					.unwrap_or(Visibility::Normal),
 				v => *v,
 			})
-		} else if let Some(super_obj) = &self.0.super_obj {
+		} else if let Some(super_obj) = &self.0.sup {
 			super_obj.field_visibility(name)
 		} else {
 			None
@@ -348,7 +349,7 @@
 	fn has_field_include_hidden(&self, name: IStr) -> bool {
 		if self.0.this_entries.contains_key(&name) {
 			true
-		} else if let Some(super_obj) = &self.0.super_obj {
+		} else if let Some(super_obj) = &self.0.sup {
 			super_obj.has_field_include_hidden(name)
 		} else {
 			false
@@ -369,13 +370,12 @@
 
 	pub fn get(&self, s: State, key: IStr) -> Result<Option<Val>> {
 		self.run_assertions(s.clone())?;
-		self.get_raw(s, key, self.0.this_obj.as_ref())
+		self.get_raw(s, key, self.0.this.clone().unwrap_or_else(|| self.clone()))
 	}
 
 	// pub fn extend_with(self, key: )
 
-	fn get_raw(&self, s: State, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {
-		let real_this = real_this.unwrap_or(self);
+	fn get_raw(&self, s: State, key: IStr, real_this: Self) -> Result<Option<Val>> {
 		let cache_key = (key.clone(), WeakObjValue(real_this.0.downgrade()));
 
 		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
@@ -397,17 +397,17 @@
 				.insert(cache_key.clone(), CacheValue::Errored(e.clone()));
 			e
 		};
-		let value = match (self.0.this_entries.get(&key), &self.0.super_obj) {
+		let value = match (self.0.this_entries.get(&key), &self.0.sup) {
 			(Some(k), None) => Ok(Some(
 				self.evaluate_this(s, k, real_this).map_err(fill_error)?,
 			)),
 			(Some(k), Some(super_obj)) => {
 				let our = self
-					.evaluate_this(s.clone(), k, real_this)
+					.evaluate_this(s.clone(), k, real_this.clone())
 					.map_err(fill_error)?;
 				if k.add {
 					super_obj
-						.get_raw(s.clone(), key, Some(real_this))
+						.get_raw(s.clone(), key, real_this)
 						.map_err(fill_error)?
 						.map_or(Ok(Some(our.clone())), |v| {
 							Ok(Some(evaluate_add_op(s.clone(), &v, &our)?))
@@ -416,7 +416,7 @@
 					Ok(Some(our))
 				}
 			}
-			(None, Some(super_obj)) => super_obj.get_raw(s, key, Some(real_this)),
+			(None, Some(super_obj)) => super_obj.get_raw(s, key, real_this),
 			(None, None) => Ok(None),
 		}
 		.map_err(fill_error)?;
@@ -429,9 +429,9 @@
 		);
 		Ok(value)
 	}
-	fn evaluate_this(&self, s: State, v: &ObjMember, real_this: &Self) -> Result<Val> {
+	fn evaluate_this(&self, s: State, v: &ObjMember, real_this: Self) -> Result<Val> {
 		v.invoke
-			.evaluate(s.clone(), Some(real_this.clone()), self.0.super_obj.clone())?
+			.evaluate(s.clone(), self.0.sup.clone(), Some(real_this))?
 			.evaluate(s)
 	}
 
@@ -439,13 +439,13 @@
 		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {
 			for assertion in self.0.assertions.iter() {
 				if let Err(e) =
-					assertion.run(s.clone(), Some(real_this.clone()), self.0.super_obj.clone())
+					assertion.run(s.clone(), self.0.sup.clone(), Some(real_this.clone()))
 				{
 					self.0.assertions_ran.borrow_mut().remove(real_this);
 					return Err(e);
 				}
 			}
-			if let Some(super_obj) = &self.0.super_obj {
+			if let Some(super_obj) = &self.0.sup {
 				super_obj.run_assertions_raw(s, real_this)?;
 			}
 		}
@@ -458,6 +458,9 @@
 	pub fn ptr_eq(a: &Self, b: &Self) -> bool {
 		cc_ptr_eq(&a.0, &b.0)
 	}
+	pub fn downgrade(self) -> WeakObjValue {
+		WeakObjValue(self.0.downgrade())
+	}
 }
 
 impl PartialEq for ObjValue {
@@ -475,7 +478,7 @@
 
 #[allow(clippy::module_name_repetitions)]
 pub struct ObjValueBuilder {
-	super_obj: Option<ObjValue>,
+	sup: Option<ObjValue>,
 	map: GcHashMap<IStr, ObjMember>,
 	assertions: Vec<TraceBox<dyn ObjectAssertion>>,
 	next_field_index: FieldIndex,
@@ -486,7 +489,7 @@
 	}
 	pub fn with_capacity(capacity: usize) -> Self {
 		Self {
-			super_obj: None,
+			sup: None,
 			map: GcHashMap::with_capacity(capacity),
 			assertions: Vec::new(),
 			next_field_index: FieldIndex::default(),
@@ -497,7 +500,7 @@
 		self
 	}
 	pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {
-		self.super_obj = Some(super_obj);
+		self.sup = Some(super_obj);
 		self
 	}
 
@@ -512,7 +515,7 @@
 	}
 
 	pub fn build(self) -> ObjValue {
-		ObjValue::new(self.super_obj, Cc::new(self.map), Cc::new(self.assertions))
+		ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))
 	}
 }
 impl Default for ObjValueBuilder {
@@ -583,7 +586,11 @@
 	pub fn value(self, s: State, value: Val) -> Result<()> {
 		self.binding(s, LazyBinding::Bound(Thunk::evaluated(value)))
 	}
-	pub fn bindable(self, s: State, bindable: TraceBox<dyn Bindable>) -> Result<()> {
+	pub fn bindable(
+		self,
+		s: State,
+		bindable: TraceBox<dyn Bindable<Bound = Thunk<Val>>>,
+	) -> Result<()> {
 		self.binding(s, LazyBinding::Bindable(Cc::new(bindable)))
 	}
 	pub fn binding(self, s: State, binding: LazyBinding) -> Result<()> {
@@ -606,7 +613,7 @@
 	pub fn value(self, value: Val) {
 		self.binding(LazyBinding::Bound(Thunk::evaluated(value)));
 	}
-	pub fn bindable(self, bindable: TraceBox<dyn Bindable>) {
+	pub fn bindable(self, bindable: TraceBox<dyn Bindable<Bound = Thunk<Val>>>) {
 		self.binding(LazyBinding::Bindable(Cc::new(bindable)));
 	}
 	pub fn binding(self, binding: LazyBinding) {

--- a/crates/jrsonnet-evaluator/src/stdlib/mod.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/mod.rs
@@ -466,7 +466,7 @@
 	Ok(ArrValue::Eager(sort::sort(
 		s.clone(),
 		arr.evaluated(s)?,
-		keyF.unwrap_or(FuncVal::identity()),
+		keyF.unwrap_or_else(FuncVal::identity),
 	)?))
 }
 

--- a/crates/jrsonnet-evaluator/src/stdlib/sort.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/sort.rs
@@ -68,7 +68,23 @@
 	if values.len() <= 1 {
 		return Ok(values);
 	}
-	if !key_getter.is_identity() {
+	if key_getter.is_identity() {
+		// Fast path, identity key getter
+		let mut values = (*values).clone();
+		let sort_type = get_sort_type(&mut values, |k| k)?;
+		match sort_type {
+			SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
+				Val::Num(n) => NonNaNf64(*n),
+				_ => unreachable!(),
+			}),
+			SortKeyType::String => values.sort_unstable_by_key(|v| match v {
+				Val::Str(s) => s.clone(),
+				_ => unreachable!(),
+			}),
+			SortKeyType::Unknown => unreachable!(),
+		};
+		Ok(Cc::new(values))
+	} else {
 		// Slow path, user provided key getter
 		let mut vk = Vec::with_capacity(values.len());
 		for value in values.iter() {
@@ -90,21 +106,5 @@
 			SortKeyType::Unknown => unreachable!(),
 		};
 		Ok(Cc::new(vk.into_iter().map(|v| v.0).collect()))
-	} else {
-		// Fast path, identity key getter
-		let mut values = (*values).clone();
-		let sort_type = get_sort_type(&mut values, |k| k)?;
-		match sort_type {
-			SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
-				Val::Num(n) => NonNaNf64(*n),
-				_ => unreachable!(),
-			}),
-			SortKeyType::String => values.sort_unstable_by_key(|v| match v {
-				Val::Str(s) => s.clone(),
-				_ => unreachable!(),
-			}),
-			SortKeyType::Unknown => unreachable!(),
-		};
-		Ok(Cc::new(values))
 	}
 }

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -8,11 +8,11 @@
 	cc_ptr_eq,
 	error::{Error::*, LocError},
 	function::FuncVal,
-	gc::TraceBox,
+	gc::{GcHashMap, TraceBox},
 	stdlib::manifest::{
 		manifest_json_ex, manifest_yaml_ex, ManifestJsonOptions, ManifestType, ManifestYamlOptions,
 	},
-	throw, ObjValue, Result, State,
+	throw, Bindable, ObjValue, Result, State, WeakObjValue,
 };
 
 pub trait ThunkValue: Trace {
@@ -71,6 +71,47 @@
 	}
 }
 
+type CacheKey = (Option<WeakObjValue>, Option<WeakObjValue>);
+
+#[derive(Trace, Clone)]
+pub struct CachedBindable<I, T>
+where
+	I: Bindable<Bound = T>,
+{
+	cache: Cc<RefCell<GcHashMap<CacheKey, T>>>,
+	value: I,
+}
+impl<I: Bindable<Bound = T>, T: Trace> CachedBindable<I, T> {
+	pub fn new(value: I) -> Self {
+		Self {
+			cache: Cc::new(RefCell::new(GcHashMap::new())),
+			value,
+		}
+	}
+}
+impl<I: Bindable<Bound = T>, T: Clone + Trace> Bindable for CachedBindable<I, T> {
+	type Bound = T;
+	fn bind(&self, s: State, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<T> {
+		let cache_key = (
+			sup.as_ref().map(|s| s.clone().downgrade()),
+			this.as_ref().map(|t| t.clone().downgrade()),
+		);
+		{
+			if let Some(t) = self.cache.borrow().get(&cache_key) {
+				return Ok(t.clone());
+			}
+		}
+		let bound = self.value.bind(s, sup, this)?;
+
+		{
+			let mut cache = self.cache.borrow_mut();
+			cache.insert(cache_key, bound.clone());
+		}
+
+		Ok(bound)
+	}
+}
+
 impl<T: Debug> Debug for Thunk<T> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f, "Lazy")

--- a/crates/jrsonnet-evaluator/tests/builtin.rs
+++ b/crates/jrsonnet-evaluator/tests/builtin.rs
@@ -6,7 +6,6 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	function::{builtin, builtin::Builtin, CallLocation, FuncVal},
-	gc::TraceBox,
 	tb,
 	typed::Typed,
 	State, Val,

--- a/crates/jrsonnet-evaluator/tests/common.rs
+++ b/crates/jrsonnet-evaluator/tests/common.rs
@@ -30,8 +30,18 @@
 		if !::jrsonnet_evaluator::val::equals($s.clone(), &$a.clone(), &$b.clone())? {
 			::jrsonnet_evaluator::throw_runtime!(
 				"assertion failed: a != b\na={:#?}\nb={:#?}",
-				$a.to_json($s.clone(), 2)?,
-				$b.to_json($s.clone(), 2)?,
+				$a.to_json(
+					$s.clone(),
+					2,
+					#[cfg(feature = "exp-preserve-order")]
+					false
+				)?,
+				$b.to_json(
+					$s.clone(),
+					2,
+					#[cfg(feature = "exp-preserve-order")]
+					false
+				)?,
 			)
 		}
 	}};

--- a/crates/jrsonnet-evaluator/tests/golden.rs
+++ b/crates/jrsonnet-evaluator/tests/golden.rs
@@ -24,7 +24,12 @@
 		Ok(v) => v,
 		Err(e) => return s.stringify_err(&e),
 	};
-	match v.to_json(s.clone(), 3) {
+	match v.to_json(
+		s.clone(),
+		3,
+		#[cfg(feature = "exp-preserve-order")]
+		false,
+	) {
 		Ok(v) => v.to_string(),
 		Err(e) => s.stringify_err(&e),
 	}

--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -165,7 +165,7 @@
 			/ string_block() } / expected!("<string>")
 
 		pub rule field_name(s: &ParserSettings) -> expr::FieldName
-			= name:id() {expr::FieldName::Fixed(name.into())}
+			= name:id() {expr::FieldName::Fixed(name)}
 			/ name:string() {expr::FieldName::Fixed(name.into())}
 			/ "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}
 		pub rule visibility() -> expr::Visibility