git.delta.rocks / jrsonnet / refs/commits / 31da3dd5cc47

1use crate::{2	create_error, Context, Error, FunctionDefault, FunctionRhs, LazyBinding, ObjValue, Result,3};4use closure::closure;5use jsonnet_parser::{Param, ParamsDesc};6use std::{7	cell::RefCell,8	collections::HashMap,9	fmt::{Debug, Display},10	rc::Rc,11};1213struct LazyValInternals {14	pub f: Option<Box<dyn Fn() -> Result<Val>>>,15	pub cached: RefCell<Option<Val>>,16}17#[derive(Clone)]18pub struct LazyVal(Rc<LazyValInternals>);19impl LazyVal {20	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {21		LazyVal(Rc::new(LazyValInternals {22			f: Some(f),23			cached: RefCell::new(None),24		}))25	}26	pub fn new_resolved(val: Val) -> Self {27		LazyVal(Rc::new(LazyValInternals {28			f: None,29			cached: RefCell::new(Some(val)),30		}))31	}32	pub fn evaluate(&self) -> Result<Val> {33		{34			let cached = self.0.cached.borrow();35			if cached.is_some() {36				return Ok(cached.clone().unwrap());37			}38		}39		let result = (self.0.f.as_ref().unwrap())()?;40		self.0.cached.borrow_mut().replace(result.clone());41		Ok(result)42	}43}4445#[macro_export]46macro_rules! lazy_val {47	($f: expr) => {48		$crate::LazyVal::new(Box::new($f))49	};50}51#[macro_export]52macro_rules! resolved_lazy_val {53	($f: expr) => {54		$crate::LazyVal::new_resolved($f)55	};56}57impl Debug for LazyVal {58	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {59		if self.0.cached.borrow().is_some() {60			write!(f, "{:?}", self.0.cached.borrow().clone().unwrap())61		} else {62			write!(f, "Lazy")63		}64	}65}66impl PartialEq for LazyVal {67	fn eq(&self, other: &Self) -> bool {68		Rc::ptr_eq(&self.0, &other.0)69	}70}7172#[derive(Debug, PartialEq, Clone)]73pub struct FuncDesc {74	pub ctx: Context,75	pub params: ParamsDesc,76	pub eval_rhs: FunctionRhs,77	pub eval_default: FunctionDefault,78}79impl FuncDesc {80	// TODO: Check for unset variables81	/// This function is always inlined to make tailstrict work82	#[inline(always)]83	pub fn evaluate(&self, args: Vec<(Option<String>, Val)>) -> Result<Val> {84		let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();85		let future_ctx = Context::new_future();8687		for Param(name, default) in self.params.with_defaults() {88			let default = default.unwrap();89			let eval_default = self.eval_default.clone();90			new_bindings.insert(91				name,92				LazyBinding::Bound(lazy_val!(93					closure!(clone future_ctx, clone eval_default, clone default, || (eval_default.clone()).094					(future_ctx.clone().unwrap(), default.clone()))95				)),96			);97		}98		for (name, val) in args.clone().into_iter().filter(|e| e.0.is_some()) {99			new_bindings.insert(100				name.as_ref().unwrap().clone(),101				LazyBinding::Bound(resolved_lazy_val!(val.clone())),102			);103		}104		for (i, param) in self.params.0.iter().enumerate() {105			if let Some((None, val)) = args.get(i) {106				new_bindings.insert(107					param.0.clone(),108					LazyBinding::Bound(resolved_lazy_val!(val.clone())),109				);110			}111		}112		let ctx = self113			.ctx114			.extend(new_bindings, None, None, None)?115			.into_future(future_ctx);116		self.eval_rhs.0(ctx)117	}118}119120#[derive(Debug)]121pub enum ValType {122	Bool,123	Null,124	Str,125	Num,126	Arr,127	Obj,128	Func,129}130impl ValType {131	pub fn name(&self) -> &'static str {132		use ValType::*;133		match self {134			Bool => "boolean",135			Null => "null",136			Str => "string",137			Num => "number",138			Arr => "array",139			Obj => "object",140			Func => "function",141		}142	}143}144impl Display for ValType {145	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {146		write!(f, "{}", self.name())147	}148}149150#[derive(Debug, PartialEq, Clone)]151pub enum Val {152	Bool(bool),153	Null,154	Str(String),155	Num(f64),156	Lazy(LazyVal),157	Arr(Vec<Val>),158	Obj(ObjValue),159	Func(FuncDesc),160161	// Library functions implemented in native162	Intristic(String, String),163}164impl Val {165	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {166		match self.unwrap_if_lazy()? {167			Val::Bool(v) => Ok(v),168			v => create_error(Error::TypeMismatch(169				context,170				vec![ValType::Bool],171				v.value_type()?,172			)),173		}174	}175	pub fn try_cast_str(self, context: &'static str) -> Result<String> {176		match self.unwrap_if_lazy()? {177			Val::Str(v) => Ok(v),178			v => create_error(Error::TypeMismatch(179				context,180				vec![ValType::Str],181				v.value_type()?,182			)),183		}184	}185	pub fn unwrap_if_lazy(self) -> Result<Self> {186		Ok(if let Val::Lazy(v) = self {187			v.evaluate()?.unwrap_if_lazy()?188		} else {189			self190		})191	}192	pub fn value_type(&self) -> Result<ValType> {193		Ok(match self {194			Val::Str(..) => ValType::Str,195			Val::Num(..) => ValType::Num,196			Val::Arr(..) => ValType::Arr,197			Val::Obj(..) => ValType::Obj,198			Val::Func(..) => ValType::Func,199			Val::Bool(_) => ValType::Bool,200			Val::Null => ValType::Null,201			Val::Intristic(_, _) => ValType::Func,202			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,203		})204	}205}