1use crate::{2 create_error, evaluate,3 function::{inline_parse_function_call, place_args},4 with_state, Context, Error, ObjValue, Result,5};6use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};7use std::{8 cell::RefCell,9 fmt::{Debug, Display},10 rc::Rc,11};1213enum LazyValInternals {14 Computed(Val),15 Waiting(Box<dyn Fn() -> Result<Val>>),16}17#[derive(Clone)]18pub struct LazyVal(Rc<RefCell<LazyValInternals>>);19impl LazyVal {20 pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {21 LazyVal(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))22 }23 pub fn new_resolved(val: Val) -> Self {24 LazyVal(Rc::new(RefCell::new(LazyValInternals::Computed(val))))25 }26 pub fn evaluate(&self) -> Result<Val> {27 let new_value = match &*self.0.borrow() {28 LazyValInternals::Computed(v) => return Ok(v.clone()),29 LazyValInternals::Waiting(f) => f()?,30 };31 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());32 Ok(new_value)33 }34}3536#[macro_export]37macro_rules! lazy_val {38 ($f: expr) => {39 $crate::LazyVal::new(Box::new($f))40 };41}42#[macro_export]43macro_rules! resolved_lazy_val {44 ($f: expr) => {45 $crate::LazyVal::new_resolved($f)46 };47}48impl Debug for LazyVal {49 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {50 write!(f, "Lazy")51 }52}53impl PartialEq for LazyVal {54 fn eq(&self, other: &Self) -> bool {55 Rc::ptr_eq(&self.0, &other.0)56 }57}5859#[derive(Debug, PartialEq, Clone)]60pub struct FuncDesc {61 pub ctx: Context,62 pub params: ParamsDesc,63 pub body: LocExpr,64}65impl FuncDesc {66 67 pub fn evaluate(&self, call_ctx: Context, args: &ArgsDesc, tailstrict: bool) -> Result<Val> {68 let ctx = inline_parse_function_call(69 call_ctx,70 Some(self.ctx.clone()),71 &self.params,72 args,73 tailstrict,74 )?;75 evaluate(ctx, &self.body)76 }7778 pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {79 let ctx = place_args(call_ctx, Some(self.ctx.clone()), &self.params, args)?;80 evaluate(ctx, &self.body)81 }82}8384#[derive(Debug, Clone, Copy, PartialEq)]85pub enum ValType {86 Bool,87 Null,88 Str,89 Num,90 Arr,91 Obj,92 Func,93}94impl ValType {95 pub fn name(&self) -> &'static str {96 use ValType::*;97 match self {98 Bool => "boolean",99 Null => "null",100 Str => "string",101 Num => "number",102 Arr => "array",103 Obj => "object",104 Func => "function",105 }106 }107}108impl Display for ValType {109 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {110 write!(f, "{}", self.name())111 }112}113114#[derive(Debug, PartialEq, Clone)]115pub enum Val {116 Bool(bool),117 Null,118 Str(Rc<str>),119 Num(f64),120 Lazy(LazyVal),121 Arr(Rc<Vec<Val>>),122 Obj(ObjValue),123 Func(FuncDesc),124125 126 Intristic(Rc<str>, Rc<str>),127}128macro_rules! matches_unwrap {129 ($e: expr, $p: pat, $r: expr) => {130 match $e {131 $p => $r,132 _ => panic!("no match"),133 }134 };135}136impl Val {137 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {138 let this_type = self.value_type()?;139 if this_type != val_type {140 create_error(Error::TypeMismatch(context, vec![val_type], this_type))141 } else {142 Ok(())143 }144 }145 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {146 self.assert_type(context, ValType::Bool)?;147 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Bool(v), v))148 }149 pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {150 self.assert_type(context, ValType::Str)?;151 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Str(v), v))152 }153 pub fn unwrap_if_lazy(&self) -> Result<Self> {154 Ok(if let Val::Lazy(v) = self {155 v.evaluate()?.unwrap_if_lazy()?156 } else {157 self.clone()158 })159 }160 pub fn value_type(&self) -> Result<ValType> {161 Ok(match self {162 Val::Str(..) => ValType::Str,163 Val::Num(..) => ValType::Num,164 Val::Arr(..) => ValType::Arr,165 Val::Obj(..) => ValType::Obj,166 Val::Func(..) => ValType::Func,167 Val::Bool(_) => ValType::Bool,168 Val::Null => ValType::Null,169 Val::Intristic(_, _) => ValType::Func,170 Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,171 })172 }173 pub fn into_json(self, padding: usize) -> Result<Rc<str>> {174 with_state(|s| {175 let ctx = s176 .create_default_context()?177 .with_var("__tmp__to_json__".into(), self)?;178 Ok(evaluate(179 ctx,180 &el!(Expr::Apply(181 el!(Expr::Index(182 el!(Expr::Var("std".into())),183 el!(Expr::Str("manifestJsonEx".into()))184 )),185 ArgsDesc(vec![186 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),187 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))188 ]),189 false190 )),191 )?192 .try_cast_str("to json")?)193 })194 }195}196197 } else {198 unreachable!()199 }200 })201 }202}