git.delta.rocks / jrsonnet / refs/commits / 5f620e2b9aa7

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -5,8 +5,8 @@
 
 use clap::{CommandFactory, Parser};
 use clap_complete::Shell;
-use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts};
-use jrsonnet_evaluator::{error::LocError, State};
+use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts, TraceOpts};
+use jrsonnet_evaluator::{apply_tla, error::LocError, throw, ResultExt, State, Val};
 
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
@@ -121,8 +121,8 @@
 }
 
 fn main_real(s: &State, opts: Opts) -> Result<(), Error> {
-	let _guards = opts.general.configure(s)?;
-	opts.manifest.configure(s)?;
+	let (_stack_guard, tla, _gc_guard) = opts.general.configure(s)?;
+	let manifest_format = opts.manifest.configure(s)?;
 
 	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;
 	let val = if opts.input.exec {
@@ -136,7 +136,7 @@
 		s.import(&input)?
 	};
 
-	let val = s.with_tla(val)?;
+	let val = apply_tla(s.clone(), &tla, val)?;
 
 	if let Some(multi) = opts.output.multi {
 		if opts.output.create_output_dirs {

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -71,7 +71,7 @@
 	misc: MiscOpts,
 
 	#[clap(flatten)]
-	tla: TLAOpts,
+	tla: TlaOpts,
 	#[clap(flatten)]
 	std: StdOpts,
 
@@ -85,16 +85,17 @@
 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
 		self.trace.configure(s)?;
 		let misc_guards = self.misc.configure(s)?;
-		self.tla.configure(s)?;
+		let tla_guards = self.tla.configure(s)?;
 		self.std.configure(s)?;
 		let gc_guards = self.gc.configure(s)?;
-		Ok((misc_guards, gc_guards))
+		Ok((misc_guards, tla_guards, gc_guards))
 	}
 }
 

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,11 +1,17 @@
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, State};
+use jrsonnet_evaluator::{
+	error::{Error, Result},
+	function::TlaArg,
+	gc::GcHashMap,
+	IStr, State,
+};
+use jrsonnet_parser::{ParserSettings, Source};
 
 use crate::{ConfigureState, ExtFile, ExtStr};
 
 #[derive(Parser)]
 #[clap(next_help_heading = "TOP LEVEL ARGUMENTS")]
-pub struct TLAOpts {
+pub struct TlaOpts {
 	/// Add top level string argument.
 	/// Top level arguments will be passed to function before manifestification stage.
 	/// This is preferred to ExtVars method.
@@ -25,21 +31,41 @@
 	#[clap(long, name = "name=tla code path", number_of_values = 1)]
 	tla_code_file: Vec<ExtFile>,
 }
-impl ConfigureState for TLAOpts {
-	type Guards = ();
-	fn configure(&self, s: &State) -> Result<()> {
-		for tla in self.tla_str.iter() {
-			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into());
+impl ConfigureState for TlaOpts {
+	type Guards = GcHashMap<IStr, TlaArg>;
+	fn configure(&self, _s: &State) -> Result<Self::Guards> {
+		let mut out = GcHashMap::new();
+		for (name, value) in self
+			.tla_str
+			.iter()
+			.map(|c| (&c.name, &c.value))
+			.chain(self.tla_str_file.iter().map(|c| (&c.name, &c.value)))
+		{
+			out.insert(name.into(), TlaArg::String(value.into()));
 		}
-		for tla in self.tla_str_file.iter() {
-			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into())
-		}
-		for tla in self.tla_code.iter() {
-			s.add_tla_code((&tla.name as &str).into(), &tla.value as &str)?;
-		}
-		for tla in self.tla_code_file.iter() {
-			s.add_tla_code((&tla.name as &str).into(), &tla.value as &str)?;
+		for (name, code) in self
+			.tla_code
+			.iter()
+			.map(|c| (&c.name, &c.value))
+			.chain(self.tla_code_file.iter().map(|c| (&c.name, &c.value)))
+		{
+			let source = Source::new_virtual(format!("<top-level-arg:{name}>").into(), code.into());
+			out.insert(
+				(&name as &str).into(),
+				TlaArg::Code(
+					jrsonnet_parser::parse(
+						&code,
+						&ParserSettings {
+							source: source.clone(),
+						},
+					)
+					.map_err(|e| Error::ImportSyntaxError {
+						path: source,
+						error: Box::new(e),
+					})?,
+				),
+			);
 		}
-		Ok(())
+		Ok(out)
 	}
 }

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -1,10 +1,11 @@
-use std::collections::HashMap;
-
+use hashbrown::HashMap;
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, LocExpr};
 
-use crate::{error::Result, evaluate, tb, typed::Typed, val::ThunkValue, Context, Thunk, Val};
+use crate::{
+	error::Result, evaluate, gc::GcHashMap, tb, typed::Typed, val::ThunkValue, Context, Thunk, Val,
+};
 
 /// Marker for arguments, which can be evaluated with context set to None
 pub trait OptionalContext {}
@@ -214,6 +215,34 @@
 }
 impl<A, S> OptionalContext for HashMap<IStr, A, S> where A: ArgLike + OptionalContext {}
 
+impl<A: ArgLike> ArgsLike for GcHashMap<IStr, A> {
+	fn unnamed_len(&self) -> usize {
+		self.0.unnamed_len()
+	}
+
+	fn unnamed_iter(
+		&self,
+		ctx: Context,
+		tailstrict: bool,
+		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
+	) -> Result<()> {
+		self.0.unnamed_iter(ctx, tailstrict, handler)
+	}
+
+	fn named_iter(
+		&self,
+		ctx: Context,
+		tailstrict: bool,
+		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
+	) -> Result<()> {
+		self.0.named_iter(ctx, tailstrict, handler)
+	}
+
+	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
+		self.0.named_names(handler)
+	}
+}
+
 macro_rules! impl_args_like {
 	($count:expr; $($gen:ident)*) => {
 		impl<$($gen: ArgLike,)*> sealed::Unnamed for ($($gen,)*) {}

55mod obj;55mod obj;
56pub mod stack;56pub mod stack;
57pub mod stdlib;57pub mod stdlib;
58mod tla;
58pub mod trace;59pub mod trace;
59pub mod typed;60pub mod typed;
60pub mod val;61pub mod val;
81use jrsonnet_parser::*;82use jrsonnet_parser::*;
82pub use obj::*;83pub use obj::*;
83use stack::check_depth;84use stack::check_depth;
84use trace::{CompactFormat, TraceFormat};85pub use tla::apply_tla;
85pub use val::{ManifestFormat, Thunk, Val};86pub use val::{ManifestFormat, Thunk, Val};
8687
87/// Thunk without bound `super`/`this`88/// Thunk without bound `super`/`this`
143/// Dynamically reconfigurable evaluation settings144/// Dynamically reconfigurable evaluation settings
144#[derive(Trace)]145#[derive(Trace)]
145pub struct EvaluationSettings {146pub struct EvaluationSettings {
146	/// Limits amount of stack trace items preserved
147	pub max_trace: usize,
148	/// TLA vars
149	pub tla_vars: HashMap<IStr, TlaArg>,
150	/// Context initializer, which will be used for imports and everything147	/// Context initializer, which will be used for imports and everything
151	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`148	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
152	pub context_initializer: TraceBox<dyn ContextInitializer>,149	pub context_initializer: TraceBox<dyn ContextInitializer>,
160impl Default for EvaluationSettings {157impl Default for EvaluationSettings {
161	fn default() -> Self {158	fn default() -> Self {
162		Self {159		Self {
163			max_trace: 20,
164			context_initializer: tb!(DummyContextInitializer),160			context_initializer: tb!(DummyContextInitializer),
165			tla_vars: HashMap::default(),
166			import_resolver: tb!(DummyImportResolver),161			import_resolver: tb!(DummyImportResolver),
167			manifest_format: ManifestFormat::Json {
168				padding: 4,
169				#[cfg(feature = "exp-preserve-order")]
170				preserve_order: false,
171			},
172			trace_format: tb!(CompactFormat {
173				padding: 4,
174				resolver: trace::PathResolver::Absolute,
175			}),
176		}162		}
177	}163	}
178}164}
406		f().with_description(frame_desc)392		f().with_description(frame_desc)
407	}393	}
408
409	/// # Panics
410	/// In case of formatting failure
411	pub fn stringify_err(&self, e: &LocError) -> String {
412		let mut out = String::new();
413		self.settings()
414			.trace_format
415			.write_trace(&mut out, self, e)
416			.unwrap();
417		out
418	}
419
420	pub fn manifest(&self, val: Val) -> Result<IStr> {
421		Self::push_description(
422			|| "manifestification".to_string(),
423			|| val.manifest(&self.manifest_format()),
424		)
425	}
426	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {
427		val.manifest_multi(&self.manifest_format())
428	}
429	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {
430		val.manifest_stream(&self.manifest_format())
431	}
432
433	/// If passed value is function then call with set TLA
434	pub fn with_tla(&self, val: Val) -> Result<Val> {
435		Ok(match val {
436			Val::Func(func) => State::push_description(
437				|| "during TLA call".to_owned(),
438				|| {
439					func.evaluate(
440						self.create_default_context(Source::new_virtual(
441							"<tla>".into(),
442							IStr::empty(),
443						)),
444						CallLocation::native(),
445						&self.settings().tla_vars,
446						true,
447					)
448				},
449			)?,
450			v => v,
451		})
452	}
453}394}
454395
455/// Internals396/// Internals
487428
488/// Settings utilities429/// Settings utilities
489impl State {430impl State {
490	pub fn add_tla(&self, name: IStr, value: Val) {
491		self.settings_mut()
492			.tla_vars
493			.insert(name, TlaArg::Val(value));
494	}
495	pub fn add_tla_str(&self, name: IStr, value: IStr) {
496		self.settings_mut()
497			.tla_vars
498			.insert(name, TlaArg::String(value));
499	}
500	pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {
501		let source_name = format!("<top-level-arg:{name}>");
502		let source = Source::new_virtual(source_name.into(), code.into());
503		let parsed = jrsonnet_parser::parse(
504			code,
505			&ParserSettings {
506				file_name: source.clone(),
507			},
508		)
509		.map_err(|e| ImportSyntaxError {
510			path: source,
511			error: Box::new(e),
512		})?;
513		self.settings_mut()
514			.tla_vars
515			.insert(name, TlaArg::Code(parsed));
516		Ok(())
517	}
518
519	// Only panics in case of [`ImportResolver`] contract violation431	// Only panics in case of [`ImportResolver`] contract violation
520	#[allow(clippy::missing_panics_doc)]432	#[allow(clippy::missing_panics_doc)]