git.delta.rocks / jrsonnet / refs/commits / 64f3674f18c4

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -139,7 +139,7 @@
 }
 
 fn main_real(s: &State, opts: Opts) -> Result<(), Error> {
-	let (_stack_guard, tla, _gc_guard) = opts.general.configure(s)?;
+	let (tla, _gc_guard) = opts.general.configure(s)?;
 	let manifest_format = opts.manifest.configure(s)?;
 
 	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -6,9 +6,7 @@
 use std::{env, marker::PhantomData, path::PathBuf};
 
 use clap::Parser;
-use jrsonnet_evaluator::{
-	error::Result, stack::StackDepthLimitOverrideGuard, FileImportResolver, State,
-};
+use jrsonnet_evaluator::{error::Result, stack::set_stack_depth_limit, FileImportResolver, State};
 use jrsonnet_gcmodule::with_thread_object_space;
 pub use manifest::*;
 pub use stdlib::*;
@@ -48,7 +46,7 @@
 	jpath: Vec<PathBuf>,
 }
 impl ConfigureState for MiscOpts {
-	type Guards = StackDepthLimitOverrideGuard;
+	type Guards = ();
 	fn configure(&self, s: &State) -> Result<Self::Guards> {
 		let mut library_paths = self.jpath.clone();
 		library_paths.reverse();
@@ -58,8 +56,8 @@
 
 		s.set_import_resolver(Box::new(FileImportResolver::new(library_paths)));
 
-		let _depth_limit = jrsonnet_evaluator::stack::limit_stack_depth(self.max_stack);
-		Ok(_depth_limit)
+		set_stack_depth_limit(self.max_stack);
+		Ok(())
 	}
 }
 
@@ -81,17 +79,16 @@
 
 impl ConfigureState for GeneralOpts {
 	type Guards = (
-		<MiscOpts as ConfigureState>::Guards,
 		<TlaOpts as ConfigureState>::Guards,
 		<GcOpts as ConfigureState>::Guards,
 	);
 	fn configure(&self, s: &State) -> Result<Self::Guards> {
 		// Configure trace first, because tla-code/ext-code can throw
-		let misc_guards = self.misc.configure(s)?;
+		self.misc.configure(s)?;
 		let tla_guards = self.tla.configure(s)?;
 		self.std.configure(s)?;
 		let gc_guards = self.gc.configure(s)?;
-		Ok((misc_guards, tla_guards, gc_guards))
+		Ok((tla_guards, gc_guards))
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -389,7 +389,7 @@
 			ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(
 				ctx.this()
 					.clone()
-					.expect("if super exists - then this should to"),
+					.expect("if super exists - then this should too"),
 			),
 		),
 		Literal(LiteralType::Dollar) => {
@@ -408,6 +408,21 @@
 			|| format!("variable <{name}> access"),
 			|| ctx.binding(name.clone())?.evaluate(),
 		)?,
+		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {
+			let name = evaluate(ctx.clone(), index)?;
+			let Val::Str(name) = name else {
+				throw!(ValueIndexMustBeTypeGot(
+					ValType::Obj,
+					ValType::Str,
+					name.value_type(),
+				))
+			};
+			ctx.super_obj()
+				.clone()
+				.expect("no super found")
+				.get_for(name, ctx.this().clone().expect("no this found"))?
+				.expect("value not found")
+		}
 		Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {
 			(Val::Obj(v), Val::Str(key)) => State::push(
 				CallLocation::new(loc),

128	assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,128	assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,
129	assertions_ran: RefCell<GcHashSet<ObjValue>>,129	assertions_ran: RefCell<GcHashSet<ObjValue>>,
130	this_entries: Cc<GcHashMap<IStr, ObjMember>>,130	this_entries: Cc<GcHashMap<IStr, ObjMember>>,
131	value_cache: RefCell<GcHashMap<IStr, CacheValue>>,131	value_cache: RefCell<GcHashMap<(IStr, Option<WeakObjValue>), CacheValue>>,
132}132}
133133
134#[derive(Clone, Trace)]134#[derive(Clone, Trace)]
387387
388	pub fn get(&self, key: IStr) -> Result<Option<Val>> {388	pub fn get(&self, key: IStr) -> Result<Option<Val>> {
389		self.run_assertions()?;389		self.run_assertions()?;
390		let cache_key = (key.clone(), None);
390		if let Some(v) = self.0.value_cache.borrow().get(&key) {391		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
391			return Ok(match v {392			return Ok(match v {
392				CacheValue::Cached(v) => Some(v.clone()),393				CacheValue::Cached(v) => Some(v.clone()),
393				CacheValue::NotFound => None,394				CacheValue::NotFound => None,
398		self.0399		self.0
399			.value_cache400			.value_cache
400			.borrow_mut()401			.borrow_mut()
401			.insert(key.clone(), CacheValue::Pending);402			.insert(cache_key.clone(), CacheValue::Pending);
402		let value = self403		let value = self
403			.get_raw(404			.get_raw(key, self.0.this.clone().unwrap_or_else(|| self.clone()))
404				key.clone(),
405				self.0.this.clone().unwrap_or_else(|| self.clone()),
406			)
407			.map_err(|e| {405			.map_err(|e| {
408				self.0406				self.0
409					.value_cache407					.value_cache
410					.borrow_mut()408					.borrow_mut()
411					.insert(key.clone(), CacheValue::Errored(e.clone()));409					.insert(cache_key.clone(), CacheValue::Errored(e.clone()));
412				e410				e
413			})?;411			})?;
414		self.0.value_cache.borrow_mut().insert(412		self.0.value_cache.borrow_mut().insert(
415			key,413			cache_key,
416			value414			value
417				.as_ref()415				.as_ref()
418				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),416				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),
419		);417		);
420		Ok(value)418		Ok(value)
421	}419	}
420	pub fn get_for(&self, key: IStr, this: Self) -> Result<Option<Val>> {
421		self.run_assertions()?;
422		let cache_key = (key.clone(), Some(this.clone().downgrade()));
423		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
424			return Ok(match v {
425				CacheValue::Cached(v) => Some(v.clone()),
426				CacheValue::NotFound => None,
427				CacheValue::Pending => throw!(InfiniteRecursionDetected),
428				CacheValue::Errored(e) => return Err(e.clone()),
429			});
430		}
431		self.0
432			.value_cache
433			.borrow_mut()
434			.insert(cache_key.clone(), CacheValue::Pending);
435		let value = self.get_raw(key, this).map_err(|e| {
436			self.0
437				.value_cache
438				.borrow_mut()
439				.insert(cache_key.clone(), CacheValue::Errored(e.clone()));
440			e
441		})?;
442		self.0.value_cache.borrow_mut().insert(
443			cache_key,
444			value
445				.as_ref()
446				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),
447		);
448		Ok(value)
449	}
422450
423	fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {451	fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {
424		match (self.0.this_entries.get(&key), &self.0.sup) {452		match (self.0.this_entries.get(&key), &self.0.sup) {