git.delta.rocks / jrsonnet / refs/commits / 7cdcae351387

1use std::fmt::Debug;23pub use arglike::{ArgLike, ArgsLike, TlaArg};4use jrsonnet_gcmodule::{Cc, Trace};5use jrsonnet_interner::IStr;6pub use jrsonnet_macros::builtin;7use jrsonnet_parser::{Destruct, Expr, LocExpr, ParamsDesc, Span};89use self::{10	arglike::OptionalContext,11	builtin::{Builtin, BuiltinParam, ParamDefault, ParamName, StaticBuiltin},12	native::NativeDesc,13	parse::{parse_default_function_call, parse_function_call},14};15use crate::{evaluate, evaluate_trivial, gc::TraceBox, tb, Context, ContextBuilder, Result, Val};1617pub mod arglike;18pub mod builtin;19pub mod native;20pub mod parse;2122/// Function callsite location.23/// Either from other jsonnet code, specified by expression location, or from native (without location).24#[derive(Clone, Copy)]25pub struct CallLocation<'l>(pub Option<&'l Span>);26impl<'l> CallLocation<'l> {27	/// Construct new location for calls coming from specified jsonnet expression location.28	pub const fn new(loc: &'l Span) -> Self {29		Self(Some(loc))30	}31}32impl CallLocation<'static> {33	/// Construct new location for calls coming from native code.34	pub const fn native() -> Self {35		Self(None)36	}37}3839/// Represents Jsonnet function defined in code.40#[derive(Debug, PartialEq, Trace)]41pub struct FuncDesc {42	/// # Example43	///44	/// In expressions like this, deducted to `a`, unspecified otherwise.45	/// ```jsonnet46	/// local a = function() ...47	/// local a() ...48	/// { a: function() ... }49	/// { a() = ... }50	/// ```51	pub name: IStr,52	/// Context, in which this function was evaluated.53	///54	/// # Example55	/// In56	/// ```jsonnet57	/// local a = 2;58	/// function() ...59	/// ```60	/// context will contain `a`.61	pub ctx: Context,6263	/// Function parameter definition64	pub params: ParamsDesc,65	/// Function body66	pub body: LocExpr,67}68impl FuncDesc {69	/// Create body context, but fill arguments without defaults with lazy error70	pub fn default_body_context(&self) -> Result<Context> {71		parse_default_function_call(self.ctx.clone(), &self.params)72	}7374	/// Create context, with which body code will run75	pub fn call_body_context(76		&self,77		call_ctx: Context,78		args: &dyn ArgsLike,79		tailstrict: bool,80	) -> Result<Context> {81		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)82	}8384	pub fn evaluate_trivial(&self) -> Option<Val> {85		evaluate_trivial(&self.body)86	}87}8889/// Represents a Jsonnet function value, including plain functions and user-provided builtins.90#[allow(clippy::module_name_repetitions)]91#[derive(Trace, Clone)]92pub enum FuncVal {93	/// Identity function, kept this way for comparsions.94	Id,95	/// Plain function implemented in jsonnet.96	Normal(Cc<FuncDesc>),97	/// Standard library function.98	StaticBuiltin(#[trace(skip)] &'static dyn StaticBuiltin),99	/// User-provided function.100	Builtin(Cc<TraceBox<dyn Builtin>>),101}102103impl Debug for FuncVal {104	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {105		match self {106			Self::Id => f.debug_tuple("Id").finish(),107			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),108			Self::StaticBuiltin(arg0) => {109				f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()110			}111			Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),112		}113	}114}115116#[allow(clippy::unnecessary_wraps)]117#[builtin]118const fn builtin_id(x: Val) -> Val {119	x120}121static ID: &builtin_id = &builtin_id {};122123impl FuncVal {124	pub fn builtin(builtin: impl Builtin) -> Self {125		Self::Builtin(Cc::new(tb!(builtin)))126	}127	pub fn static_builtin(static_builtin: &'static dyn StaticBuiltin) -> Self {128		Self::StaticBuiltin(static_builtin)129	}130131	pub fn params(&self) -> Vec<BuiltinParam> {132		match self {133			Self::Id => ID.params().to_vec(),134			Self::StaticBuiltin(i) => i.params().to_vec(),135			Self::Builtin(i) => i.params().to_vec(),136			Self::Normal(p) => p137				.params138				.iter()139				.map(|p| {140					BuiltinParam::new(141						p.0.name()142							.as_ref()143							.map(IStr::to_string)144							.map_or(ParamName::ANONYMOUS, ParamName::new_dynamic),145						ParamDefault::exists(p.1.is_some()),146					)147				})148				.collect(),149		}150	}151	/// Amount of non-default required arguments152	pub fn params_len(&self) -> usize {153		match self {154			Self::Id => 1,155			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),156			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default()).count(),157			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default()).count(),158		}159	}160	/// Function name, as defined in code.161	pub fn name(&self) -> IStr {162		match self {163			Self::Id => "id".into(),164			Self::Normal(normal) => normal.name.clone(),165			Self::StaticBuiltin(builtin) => builtin.name().into(),166			Self::Builtin(builtin) => builtin.name().into(),167		}168	}169	/// Call function using arguments evaluated in specified `call_ctx` [`Context`].170	///171	/// If `tailstrict` is specified - then arguments will be evaluated before being passed to function body.172	pub fn evaluate(173		&self,174		call_ctx: Context,175		loc: CallLocation<'_>,176		args: &dyn ArgsLike,177		tailstrict: bool,178	) -> Result<Val> {179		match self {180			Self::Id => ID.call(call_ctx, loc, args),181			Self::Normal(func) => {182				let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;183				evaluate(body_ctx, &func.body)184			}185			Self::StaticBuiltin(b) => b.call(call_ctx, loc, args),186			Self::Builtin(b) => b.call(call_ctx, loc, args),187		}188	}189	pub fn evaluate_simple<A: ArgsLike + OptionalContext>(190		&self,191		args: &A,192		tailstrict: bool,193	) -> Result<Val> {194		self.evaluate(195			ContextBuilder::dangerous_empty_state().build(),196			CallLocation::native(),197			args,198			tailstrict,199		)200	}201	/// Convert jsonnet function to plain `Fn` value.202	pub fn into_native<D: NativeDesc>(self) -> D::Value {203		D::into_native(self)204	}205206	/// Is this function an indentity function.207	///208	/// Currently only works for builtin `std.id`, aka `Self::Id` value, and `function(x) x`.209	///210	/// This function should only be used for optimization, not for the conditional logic, i.e code should work with syntetic identity function too211	pub fn is_identity(&self) -> bool {212		match self {213			Self::Id => true,214			Self::Normal(desc) => {215				if desc.params.len() != 1 {216					return false;217				}218				let param = &desc.params[0];219				if param.1.is_some() {220					return false;221				}222				#[allow(clippy::infallible_destructuring_match)]223				let id = match &param.0 {224					Destruct::Full(id) => id,225					#[cfg(feature = "exp-destruct")]226					_ => return false,227				};228				desc.body.expr() == &Expr::Var(id.clone())229			}230			_ => false,231		}232	}233	/// Identity function value.234	pub const fn identity() -> Self {235		Self::Id236	}237238	pub fn evaluate_trivial(&self) -> Option<Val> {239		match self {240			Self::Normal(n) => n.evaluate_trivial(),241			_ => None,242		}243	}244}245246impl<T> From<T> for FuncVal247where248	T: Builtin,249{250	fn from(value: T) -> Self {251		Self::builtin(value)252	}253}254impl From<&'static dyn StaticBuiltin> for FuncVal {255	fn from(value: &'static dyn StaticBuiltin) -> Self {256		Self::static_builtin(value)257	}258}