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

1use hashbrown::HashMap;2use jrsonnet_gcmodule::Trace;3use jrsonnet_interner::IStr;4use jrsonnet_parser::{ArgsDesc, LocExpr};56use crate::{7	error::Result, evaluate, gc::GcHashMap, tb, typed::Typed, val::ThunkValue, Context, Thunk, Val,8};910/// Marker for arguments, which can be evaluated with context set to None11pub trait OptionalContext {}1213#[derive(Trace)]14struct EvaluateThunk {15	ctx: Context,16	expr: LocExpr,17}18impl ThunkValue for EvaluateThunk {19	type Output = Val;20	fn get(self: Box<Self>) -> Result<Val> {21		evaluate(self.ctx, &self.expr)22	}23}2425pub trait ArgLike {26	fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>>;27}2829impl ArgLike for &LocExpr {30	fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {31		Ok(if tailstrict {32			Thunk::evaluated(evaluate(ctx, self)?)33		} else {34			Thunk::new(tb!(EvaluateThunk {35				ctx,36				expr: (*self).clone(),37			}))38		})39	}40}4142impl<T> ArgLike for T43where44	T: Typed + Clone,45{46	fn evaluate_arg(&self, _ctx: Context, _tailstrict: bool) -> Result<Thunk<Val>> {47		let val = T::into_untyped(self.clone())?;48		Ok(Thunk::evaluated(val))49	}50}51impl<T> OptionalContext for T where T: Typed + Clone {}5253#[derive(Clone, Trace)]54pub enum TlaArg {55	String(IStr),56	Code(LocExpr),57	Val(Val),58}59impl ArgLike for TlaArg {60	fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {61		match self {62			TlaArg::String(s) => Ok(Thunk::evaluated(Val::Str(s.clone()))),63			TlaArg::Code(code) => Ok(if tailstrict {64				Thunk::evaluated(evaluate(ctx, code)?)65			} else {66				Thunk::new(tb!(EvaluateThunk {67					ctx,68					expr: code.clone(),69				}))70			}),71			TlaArg::Val(val) => Ok(Thunk::evaluated(val.clone())),72		}73	}74}7576mod sealed {77	/// Implemented for `ArgsLike`, where only unnamed arguments present78	pub trait Unnamed {}79	/// Implemented for `ArgsLike`, where only named arguments present80	pub trait Named {}81}8283pub trait ArgsLike {84	fn unnamed_len(&self) -> usize;85	fn unnamed_iter(86		&self,87		ctx: Context,88		tailstrict: bool,89		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,90	) -> Result<()>;91	fn named_iter(92		&self,93		ctx: Context,94		tailstrict: bool,95		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,96	) -> Result<()>;97	fn named_names(&self, handler: &mut dyn FnMut(&IStr));98}99100impl ArgsLike for Vec<Val> {101	fn unnamed_len(&self) -> usize {102		self.len()103	}104	fn unnamed_iter(105		&self,106		_ctx: Context,107		_tailstrict: bool,108		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,109	) -> Result<()> {110		for (idx, el) in self.iter().enumerate() {111			handler(idx, Thunk::evaluated(el.clone()))?;112		}113		Ok(())114	}115	fn named_iter(116		&self,117		_ctx: Context,118		_tailstrict: bool,119		_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,120	) -> Result<()> {121		Ok(())122	}123	fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}124}125impl OptionalContext for Vec<Val> {}126127impl ArgsLike for ArgsDesc {128	fn unnamed_len(&self) -> usize {129		self.unnamed.len()130	}131132	fn unnamed_iter(133		&self,134		ctx: Context,135		tailstrict: bool,136		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,137	) -> Result<()> {138		for (id, arg) in self.unnamed.iter().enumerate() {139			handler(140				id,141				if tailstrict {142					Thunk::evaluated(evaluate(ctx.clone(), arg)?)143				} else {144					Thunk::new(tb!(EvaluateThunk {145						ctx: ctx.clone(),146						expr: arg.clone(),147					}))148				},149			)?;150		}151		Ok(())152	}153154	fn named_iter(155		&self,156		ctx: Context,157		tailstrict: bool,158		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,159	) -> Result<()> {160		for (name, arg) in &self.named {161			handler(162				name,163				if tailstrict {164					Thunk::evaluated(evaluate(ctx.clone(), arg)?)165				} else {166					Thunk::new(tb!(EvaluateThunk {167						ctx: ctx.clone(),168						expr: arg.clone(),169					}))170				},171			)?;172		}173		Ok(())174	}175176	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {177		for (name, _) in &self.named {178			handler(name);179		}180	}181}182183impl<A: ArgLike, S> sealed::Named for HashMap<IStr, A, S> {}184impl<A: ArgLike, S> ArgsLike for HashMap<IStr, A, S> {185	fn unnamed_len(&self) -> usize {186		0187	}188189	fn unnamed_iter(190		&self,191		_ctx: Context,192		_tailstrict: bool,193		_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,194	) -> Result<()> {195		Ok(())196	}197198	fn named_iter(199		&self,200		ctx: Context,201		tailstrict: bool,202		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,203	) -> Result<()> {204		for (name, value) in self.iter() {205			handler(name, value.evaluate_arg(ctx.clone(), tailstrict)?)?;206		}207		Ok(())208	}209210	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {211		for (name, _) in self.iter() {212			handler(name);213		}214	}215}216impl<A, S> OptionalContext for HashMap<IStr, A, S> where A: ArgLike + OptionalContext {}217218impl<A: ArgLike> ArgsLike for GcHashMap<IStr, A> {219	fn unnamed_len(&self) -> usize {220		self.0.unnamed_len()221	}222223	fn unnamed_iter(224		&self,225		ctx: Context,226		tailstrict: bool,227		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,228	) -> Result<()> {229		self.0.unnamed_iter(ctx, tailstrict, handler)230	}231232	fn named_iter(233		&self,234		ctx: Context,235		tailstrict: bool,236		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,237	) -> Result<()> {238		self.0.named_iter(ctx, tailstrict, handler)239	}240241	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {242		self.0.named_names(handler)243	}244}245246macro_rules! impl_args_like {247	($count:expr; $($gen:ident)*) => {248		impl<$($gen: ArgLike,)*> sealed::Unnamed for ($($gen,)*) {}249		impl<$($gen: ArgLike,)*> ArgsLike for ($($gen,)*) {250			fn unnamed_len(&self) -> usize {251				$count252			}253			#[allow(non_snake_case, unused_assignments)]254			fn unnamed_iter(255				&self,256				ctx: Context,257				tailstrict: bool,258				handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,259			) -> Result<()> {260				let mut i = 0usize;261				let ($($gen,)*) = self;262				$(263					handler(i, $gen.evaluate_arg(ctx.clone(), tailstrict)?)?;264					i+=1;265				)*266				Ok(())267			}268			fn named_iter(269				&self,270				_ctx: Context,271				_tailstrict: bool,272				_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,273			) -> Result<()> {274				Ok(())275			}276			fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}277		}278		impl<$($gen: ArgLike,)*> OptionalContext for ($($gen,)*) where $($gen: OptionalContext),* {}279280		impl<$($gen: ArgLike,)*> sealed::Named for ($((IStr, $gen),)*) {}281		impl<$($gen: ArgLike,)*> ArgsLike for ($((IStr, $gen),)*) {282			fn unnamed_len(&self) -> usize {283				0284			}285			fn unnamed_iter(286				&self,287				_ctx: Context,288				_tailstrict: bool,289				_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,290			) -> Result<()> {291				Ok(())292			}293			#[allow(non_snake_case)]294			fn named_iter(295				&self,296				ctx: Context,297				tailstrict: bool,298				handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,299			) -> Result<()> {300				let ($($gen,)*) = self;301				$(302					handler(&$gen.0, $gen.1.evaluate_arg(ctx.clone(), tailstrict)?)?;303				)*304				Ok(())305			}306			#[allow(non_snake_case)]307			fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {308				let ($($gen,)*) = self;309				$(310					handler(&$gen.0);311				)*312			}313		}314		impl<$($gen: ArgLike,)*> OptionalContext for ($((IStr, $gen),)*) where $($gen: OptionalContext),* {}315	};316	($count:expr; $($cur:ident)* @ $c:ident $($rest:ident)*) => {317		impl_args_like!($count; $($cur)*);318		impl_args_like!($count + 1usize; $($cur)* $c @ $($rest)*);319	};320	($count:expr; $($cur:ident)* @) => {321		impl_args_like!($count; $($cur)*);322	}323}324impl_args_like! {325	// First argument is already in position, so count starts from 1326	1usize; A @ B C D E F G H I J K L327}328329impl ArgsLike for () {330	fn unnamed_len(&self) -> usize {331		0332	}333334	fn unnamed_iter(335		&self,336		_ctx: Context,337		_tailstrict: bool,338		_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,339	) -> Result<()> {340		Ok(())341	}342343	fn named_iter(344		&self,345		_ctx: Context,346		_tailstrict: bool,347		_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,348	) -> Result<()> {349		Ok(())350	}351352	fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}353}354impl OptionalContext for () {}