git.delta.rocks / jrsonnet / refs/commits / 1c69f1ac7855

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -247,7 +247,7 @@
 	match vm
 		.state
 		.import(filename)
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val.manifest(&vm.manifest_format))
 	{
 		Ok(v) => {
@@ -282,7 +282,7 @@
 	match vm
 		.state
 		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val.manifest(&vm.manifest_format))
 	{
 		Ok(v) => {
@@ -340,7 +340,7 @@
 	match vm
 		.state
 		.import(filename)
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val_to_multi(val, &vm.manifest_format))
 	{
 		Ok(v) => {
@@ -369,7 +369,7 @@
 	match vm
 		.state
 		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val_to_multi(val, &vm.manifest_format))
 	{
 		Ok(v) => {
@@ -422,7 +422,7 @@
 	match vm
 		.state
 		.import(filename)
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val_to_stream(val, &vm.manifest_format))
 	{
 		Ok(v) => {
@@ -451,7 +451,7 @@
 	match vm
 		.state
 		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
-		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))
+		.and_then(|val| apply_tla(&vm.tla_args, val))
 		.and_then(|val| val_to_stream(val, &vm.manifest_format))
 	{
 		Ok(v) => {

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -173,6 +173,7 @@
 	let mut s = State::builder();
 	s.import_resolver(import_resolver).context_initializer(std);
 	let s = s.build();
+	let _s = s.enter();
 
 	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;
 	let val = if opts.input.exec {
@@ -192,7 +193,7 @@
 		unused_mut,
 		clippy::redundant_clone,
 	)]
-	let mut val = apply_tla(s.clone(), &tla, val)?;
+	let mut val = apply_tla(&tla, val)?;
 
 	#[cfg(feature = "exp-apply")]
 	for apply in opts.input.exp_apply {

66
7use crate::{7use crate::{
8	error::ErrorKind::*, gc::WithCapacityExt as _, map::LayeredHashMap, ObjValue, Pending, Result,8	error::ErrorKind::*, gc::WithCapacityExt as _, map::LayeredHashMap, ObjValue, Pending, Result,
9	State, Thunk, Val,9	Thunk, Val,
10};10};
1111
12#[derive(Trace)]12#[derive(Trace)]
13struct ContextInternals {13struct ContextInternals {
14	state: Option<State>,
15	dollar: Option<ObjValue>,14	dollar: Option<ObjValue>,
16	sup: Option<ObjValue>,15	sup: Option<ObjValue>,
17	this: Option<ObjValue>,16	this: Option<ObjValue>,
33		Pending::new()32		Pending::new()
34	}33	}
35
36	pub fn state(&self) -> &State {
37		self.0
38			.state
39			.as_ref()
40			.expect("used state from dummy context")
41	}
4234
43	pub fn dollar(&self) -> Option<&ObjValue> {35	pub fn dollar(&self) -> Option<&ObjValue> {
44		self.0.dollar.as_ref()36		self.0.dollar.as_ref()
112			ctx.bindings.clone().extend(new_bindings)104			ctx.bindings.clone().extend(new_bindings)
113		};105		};
114		Self(Cc::new(ContextInternals {106		Self(Cc::new(ContextInternals {
115			state: ctx.state.clone(),
116			dollar,107			dollar,
117			sup,108			sup,
118			this,109			this,
128}119}
129120
130pub struct ContextBuilder {121pub struct ContextBuilder {
131	state: Option<State>,
132	bindings: FxHashMap<IStr, Thunk<Val>>,122	bindings: FxHashMap<IStr, Thunk<Val>>,
133	extend: Option<Context>,123	extend: Option<Context>,
134}124}
135125
136impl ContextBuilder {126impl ContextBuilder {
137	/// # Panics
138	/// Panics aren't directly caused by this function, but if state from resulting context is used
139	pub fn dangerous_empty_state() -> Self {
140		Self {
141			state: None,
142			bindings: FxHashMap::new(),
143			extend: None,
144		}
145	}
146	pub fn new(state: State) -> Self {127	pub fn new() -> Self {
147		Self::with_capacity(state, 0)128		Self::with_capacity(0)
148	}129	}
149	pub fn with_capacity(state: State, capacity: usize) -> Self {130	pub fn with_capacity(capacity: usize) -> Self {
150		Self {131		Self {
151			state: Some(state),
152			bindings: FxHashMap::with_capacity(capacity),132			bindings: FxHashMap::with_capacity(capacity),
153			extend: None,133			extend: None,
154		}134		}
155	}135	}
156	pub fn extend(parent: Context) -> Self {136	pub fn extend(parent: Context) -> Self {
157		Self {137		Self {
158			state: parent.0.state.clone(),
159			bindings: FxHashMap::new(),138			bindings: FxHashMap::new(),
160			extend: Some(parent),139			extend: Some(parent),
161		}140		}
173			parent.extend(self.bindings, None, None, None)152			parent.extend(self.bindings, None, None, None)
174		} else {153		} else {
175			Context(Cc::new(ContextInternals {154			Context(Cc::new(ContextInternals {
176				state: self.state,
177				bindings: LayeredHashMap::new(self.bindings),155				bindings: LayeredHashMap::new(self.bindings),
178				dollar: None,156				dollar: None,
179				sup: None,157				sup: None,

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -4,7 +4,7 @@
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, LocExpr, SourceFifo, SourcePath};
 
-use crate::{evaluate, typed::Typed, Context, Result, Thunk, Val};
+use crate::{evaluate, typed::Typed, with_state, Context, Result, Thunk, Val};
 
 /// Marker for arguments, which can be evaluated with context set to None
 pub trait OptionalContext {}
@@ -47,28 +47,59 @@
 	ImportStr(String),
 	InlineCode(String),
 }
-impl ArgLike for TlaArg {
-	fn evaluate_arg(&self, ctx: Context, _tailstrict: bool) -> Result<Thunk<Val>> {
+impl TlaArg {
+	pub fn evaluate_tailstrict(&self) -> Result<Val> {
 		match self {
+			Self::String(s) => Ok(Val::string(s.clone())),
+			Self::Val(val) => Ok(val.clone()),
+			Self::Lazy(lazy) => Ok(lazy.evaluate()?),
+			Self::Import(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				s.import_resolved(resolved)
+			}),
+			Self::ImportStr(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				s.import_resolved_str(resolved).map(Val::string)
+			}),
+			Self::InlineCode(p) => with_state(|s| {
+				let resolved =
+					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
+				s.import_resolved(resolved)
+			}),
+		}
+	}
+	pub fn evaluate(&self) -> Result<Thunk<Val>> {
+		match self {
 			Self::String(s) => Ok(Thunk::evaluated(Val::string(s.clone()))),
 			Self::Val(val) => Ok(Thunk::evaluated(val.clone())),
 			Self::Lazy(lazy) => Ok(lazy.clone()),
-			Self::Import(p) => {
-				let resolved = ctx.state().resolve_from_default(&p.as_str())?;
-				Ok(Thunk!(move || ctx.state().import_resolved(resolved)))
-			}
-			Self::ImportStr(p) => {
-				let resolved = ctx.state().resolve_from_default(&p.as_str())?;
-				Ok(Thunk!(move || ctx
-					.state()
+			Self::Import(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				Ok(Thunk!(move || s.import_resolved(resolved)))
+			}),
+			Self::ImportStr(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				Ok(Thunk!(move || s
 					.import_resolved_str(resolved)
 					.map(Val::string)))
-			}
-			Self::InlineCode(p) => {
+			}),
+			Self::InlineCode(p) => with_state(|s| {
 				let resolved =
 					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
-				Ok(Thunk!(move || ctx.state().import_resolved(resolved)))
-			}
+				Ok(Thunk!(move || s.import_resolved(resolved)))
+			}),
+		}
+	}
+}
+
+// TODO: Is this implementation really required, as there is no Context to use?
+// Maybe something a bit stricter is possible to add, especially with precompiled calls?
+impl ArgLike for TlaArg {
+	fn evaluate_arg(&self, _ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
+		if tailstrict {
+			self.evaluate_tailstrict().map(Thunk::evaluated)
+		} else {
+			self.evaluate()
 		}
 	}
 }

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -207,7 +207,7 @@
 		tailstrict: bool,
 	) -> Result<Val> {
 		self.evaluate(
-			ContextBuilder::dangerous_empty_state().build(),
+			ContextBuilder::new().build(),
 			CallLocation::native(),
 			args,
 			tailstrict,

--- a/crates/jrsonnet-evaluator/src/tla.rs
+++ b/crates/jrsonnet-evaluator/src/tla.rs
@@ -1,21 +1,24 @@
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::Source;
+use rustc_hash::FxHashMap;
 
 use crate::{
-	function::{ArgsLike, CallLocation},
-	in_description_frame, Result, State, Val,
+	function::{CallLocation, TlaArg},
+	in_description_frame, with_state, Result, Val,
 };
 
-pub fn apply_tla<A: ArgsLike>(s: State, args: &A, val: Val) -> Result<Val> {
+pub fn apply_tla(args: &FxHashMap<IStr, TlaArg>, val: Val) -> Result<Val> {
 	Ok(if let Val::Func(func) = val {
 		in_description_frame(
 			|| "during TLA call".to_owned(),
 			|| {
 				func.evaluate(
-					s.create_default_context(Source::new_virtual(
-						"<top-level-arg>".into(),
-						IStr::empty(),
-					)),
+					with_state(|s| {
+						s.create_default_context(Source::new_virtual(
+							"<top-level-arg>".into(),
+							IStr::empty(),
+						))
+					}),
 					CallLocation::native(),
 					args,
 					false,

--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -335,11 +335,6 @@
 	pub path_resolver: PathResolver,
 }
 
-fn extvar_source(name: &str, code: impl Into<IStr>) -> Source {
-	let source_name = format!("<extvar:{name}>");
-	Source::new_virtual(source_name.into(), code.into())
-}
-
 #[derive(Trace, Clone)]
 pub struct ContextInitializer {
 	/// std without applied thisFile overlay

--- a/crates/jrsonnet-stdlib/src/misc.rs
+++ b/crates/jrsonnet-stdlib/src/misc.rs
@@ -3,15 +3,15 @@
 use jrsonnet_evaluator::{
 	bail,
 	error::{ErrorKind::*, Result},
-	function::{builtin, ArgLike, CallLocation, FuncVal},
+	function::{builtin, CallLocation, FuncVal},
 	manifest::JsonFormat,
 	typed::{Either2, Either4},
 	val::{equals, ArrValue},
-	Context, Either, IStr, ObjValue, ObjValueBuilder, ResultExt, Thunk, Val,
+	Either, IStr, ObjValue, ObjValueBuilder, ResultExt, Thunk, Val,
 };
 use jrsonnet_gcmodule::Cc;
 
-use crate::{extvar_source, Settings};
+use crate::Settings;
 
 #[builtin]
 pub fn builtin_length(x: Either![IStr, ArrValue, ObjValue, FuncVal]) -> usize {
@@ -50,16 +50,14 @@
 #[builtin(fields(
 	settings: Cc<RefCell<Settings>>,
 ))]
-pub fn builtin_ext_var(this: &builtin_ext_var, ctx: Context, x: IStr) -> Result<Val> {
-	let ctx = ctx.state().create_default_context(extvar_source(&x, ""));
+pub fn builtin_ext_var(this: &builtin_ext_var, x: IStr) -> Result<Val> {
 	this.settings
 		.borrow()
 		.ext_vars
 		.get(&x)
 		.cloned()
 		.ok_or_else(|| UndefinedExternalVariable(x))?
-		.evaluate_arg(ctx, true)?
-		.evaluate()
+		.evaluate_tailstrict()
 }
 
 #[builtin(fields(

--- a/tests/tests/builtin.rs
+++ b/tests/tests/builtin.rs
@@ -19,7 +19,7 @@
 fn basic_function() -> Result<()> {
 	let a: a = a {};
 	let v = u32::from_untyped(a.call(
-		ContextBuilder::dangerous_empty_state().build(),
+		ContextBuilder::new().build(),
 		CallLocation::native(),
 		&(),
 	)?)?;