git.delta.rocks / jrsonnet / refs/commits / 0111266c91b4

1use std::{fmt::Debug, rc::Rc};23pub use arglike::{ArgLike, ArgsLike, TlaArg};4use educe::Educe;5use jrsonnet_gcmodule::{Cc, Trace};6use jrsonnet_interner::IStr;7pub use jrsonnet_macros::builtin;8use jrsonnet_parser::{Destruct, Expr, ExprParams, Span, Spanned};910use self::{11	arglike::OptionalContext,12	builtin::{Builtin, StaticBuiltin},13	native::NativeDesc,14	parse::{parse_builtin_call, parse_default_function_call, parse_function_call},15	prepared::{parse_prepared_builtin_call, parse_prepared_function_call, PreparedCall},16};17use crate::{18	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,19	ContextBuilder, Result, Thunk, Val,20};2122pub mod arglike;23pub mod builtin;24pub mod native;25pub mod parse;26mod prepared;2728pub use prepared::PreparedFuncVal;2930pub use jrsonnet_parser::function::*;3132/// Function callsite location.33/// Either from other jsonnet code, specified by expression location, or from native (without location).34#[derive(Clone, Copy)]35pub struct CallLocation<'l>(pub Option<&'l Span>);36impl<'l> CallLocation<'l> {37	/// Construct new location for calls coming from specified jsonnet expression location.38	pub const fn new(loc: &'l Span) -> Self {39		Self(Some(loc))40	}41}42impl CallLocation<'static> {43	/// Construct new location for calls coming from native code.44	pub const fn native() -> Self {45		Self(None)46	}47}4849/// Represents Jsonnet function defined in code.50#[derive(Trace, Educe)]51#[educe(Debug, PartialEq)]52pub struct FuncDesc {53	/// # Example54	///55	/// In expressions like this, deducted to `a`, unspecified otherwise.56	/// ```jsonnet57	/// local a = function() ...58	/// local a() ...59	/// { a: function() ... }60	/// { a() = ... }61	/// ```62	pub name: IStr,63	/// Context, in which this function was evaluated.64	///65	/// # Example66	/// In67	/// ```jsonnet68	/// local a = 2;69	/// function() ...70	/// ```71	/// context will contain `a`.72	pub ctx: Context,7374	/// Function parameter definition75	pub params: ExprParams,76	/// Function body77	pub body: Rc<Spanned<Expr>>,78}79impl FuncDesc {80	/// Create body context, but fill arguments without defaults with lazy error81	pub fn default_body_context(&self) -> Result<Context> {82		parse_default_function_call(self.ctx.clone(), &self.params)83	}8485	/// Create context, with which body code will run86	pub fn call_body_context(87		&self,88		call_ctx: Context,89		args: &dyn ArgsLike,90		tailstrict: bool,91	) -> Result<Context> {92		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)93	}9495	pub fn evaluate_trivial(&self) -> Option<Val> {96		evaluate_trivial(&self.body)97	}98}99100/// Represents a Jsonnet function value, including plain functions and user-provided builtins.101#[allow(clippy::module_name_repetitions)]102#[derive(Trace, Clone)]103pub enum FuncVal {104	/// Identity function, kept this way for comparsions.105	Id,106	/// Plain function implemented in jsonnet.107	Normal(Cc<FuncDesc>),108	/// Function without arguments works just as a fancy thunk value.109	Thunk(Thunk<Val>),110	/// Standard library function.111	StaticBuiltin(#[trace(skip)] &'static dyn StaticBuiltin),112	/// User-provided function.113	Builtin(BuiltinFunc),114}115116impl Debug for FuncVal {117	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {118		match self {119			Self::Id => f.debug_tuple("Id").finish(),120			Self::Thunk(arg0) => f.debug_tuple("Thunk").field(arg0).finish(),121			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),122			Self::StaticBuiltin(arg0) => {123				f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()124			}125			Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),126		}127	}128}129130#[allow(clippy::unnecessary_wraps)]131#[builtin]132const fn builtin_id(x: Val) -> Val {133	x134}135static ID: &builtin_id = &builtin_id {};136137impl FuncVal {138	pub fn builtin(builtin: impl Builtin) -> Self {139		Self::Builtin(BuiltinFunc::new(builtin))140	}141	pub fn static_builtin(static_builtin: &'static dyn StaticBuiltin) -> Self {142		Self::StaticBuiltin(static_builtin)143	}144145	pub fn params(&self) -> FunctionSignature {146		match self {147			Self::Id => ID.params(),148			Self::StaticBuiltin(i) => i.params(),149			Self::Builtin(i) => i.params(),150			Self::Normal(p) => p.params.signature.clone(),151			Self::Thunk(_) => FunctionSignature::empty(),152		}153	}154	/// Amount of non-default required arguments155	pub fn params_len(&self) -> usize {156		self.params().iter().filter(|p| !p.has_default()).count()157	}158	/// Function name, as defined in code.159	pub fn name(&self) -> IStr {160		match self {161			Self::Id => "id".into(),162			Self::Normal(normal) => normal.name.clone(),163			Self::StaticBuiltin(builtin) => builtin.name().into(),164			Self::Builtin(builtin) => builtin.name().into(),165			Self::Thunk(_) => "thunk".into(),166		}167	}168	/// Call function using arguments evaluated in specified `call_ctx` [`Context`].169	///170	/// If `tailstrict` is specified - then arguments will be evaluated before being passed to function body.171	pub fn evaluate(172		&self,173		call_ctx: Context,174		loc: CallLocation<'_>,175		args: &dyn ArgsLike,176		tailstrict: bool,177	) -> Result<Val> {178		match self {179			Self::Normal(func) => {180				let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;181				evaluate(body_ctx, &func.body)182			}183			Self::Thunk(thunk) => {184				if !args.is_empty() {185					bail!(TooManyArgsFunctionHas(0, FunctionSignature::empty()))186				}187				thunk.evaluate()188			}189			Self::Id => {190				let args = parse_builtin_call(call_ctx, ID.params(), args, tailstrict)?;191				ID.call(loc, &args)192			}193			Self::StaticBuiltin(b) => {194				let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;195				b.call(loc, &args)196			}197			Self::Builtin(b) => {198				let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;199				b.call(loc, &args)200			}201		}202	}203	pub fn evaluate_simple<A: ArgsLike + OptionalContext>(204		&self,205		args: &A,206		tailstrict: bool,207	) -> Result<Val> {208		self.evaluate(209			ContextBuilder::new().build(),210			CallLocation::native(),211			args,212			tailstrict,213		)214	}215216	pub(crate) fn evaluate_prepared(217		&self,218		prepared: &PreparedCall,219		loc: CallLocation<'_>,220		unnamed: &[Thunk<Val>],221		named: &[Thunk<Val>],222		_tailstrict: bool,223	) -> Result<Val> {224		match self {225			FuncVal::Id => {226				let args = parse_prepared_builtin_call(prepared, ID.params(), unnamed, named)?;227				ID.call(loc, &args)228			}229			FuncVal::Normal(func) => {230				let body_ctx = parse_prepared_function_call(231					func.ctx.clone(),232					prepared,233					&func.params,234					unnamed,235					named,236				)?;237				evaluate(body_ctx, &func.body)238			}239			FuncVal::Thunk(t) => t.evaluate(),240			FuncVal::StaticBuiltin(b) => {241				let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named)?;242				b.call(loc, &args)243			}244			FuncVal::Builtin(b) => {245				let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named)?;246				b.call(loc, &args)247			}248		}249	}250	/// Convert jsonnet function to plain `Fn` value.251	pub fn into_native<D: NativeDesc>(self) -> D::Value {252		D::into_native(self)253	}254255	/// Is this function an indentity function.256	///257	/// Currently only works for builtin `std.id`, aka `Self::Id` value, and `function(x) x`.258	///259	/// This function should only be used for optimization, not for the conditional logic, i.e code should work with syntetic identity function too260	pub fn is_identity(&self) -> bool {261		match self {262			Self::Id => true,263			Self::Normal(desc) => {264				if desc.params.len() != 1 {265					return false;266				}267				let param = &desc.params.exprs[0];268				if param.default.is_some() {269					return false;270				}271272				#[allow(clippy::infallible_destructuring_match)]273				let id = match &param.destruct {274					Destruct::Full(id) => id,275					#[cfg(feature = "exp-destruct")]276					_ => return false,277				};278				**desc.body == Expr::Var(id.clone())279			}280			_ => false,281		}282	}283	/// Identity function value.284	pub const fn identity() -> Self {285		Self::Id286	}287288	pub fn evaluate_trivial(&self) -> Option<Val> {289		match self {290			Self::Normal(n) => n.evaluate_trivial(),291			_ => None,292		}293	}294}295296impl<T> From<T> for FuncVal297where298	T: Builtin,299{300	fn from(value: T) -> Self {301		Self::builtin(value)302	}303}304impl From<&'static dyn StaticBuiltin> for FuncVal {305	fn from(value: &'static dyn StaticBuiltin) -> Self {306		Self::static_builtin(value)307	}308}