git.delta.rocks / jrsonnet / refs/commits / 432b17211316

1use crate::{2	binding, context_creator, create_error, function_default, function_rhs, future_wrapper,3	lazy_binding, lazy_val, push, Context, ContextCreator, FuncDesc, LazyBinding, ObjMember,4	ObjValue, Result, Val,5};6use closure::closure;7use jsonnet_parser::{8	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, ForSpecData,9	IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType, Visibility,10};11use std::{12	collections::{BTreeMap, HashMap},13	rc::Rc,14};1516pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (String, LazyBinding) {17	let b = b.clone();18	if let Some(args) = &b.params {19		let args = args.clone();20		(21			b.name.clone(),22			lazy_binding!(move |this, super_obj| Ok(lazy_val!(23				closure!(clone b, clone args, clone context_creator, || Ok(evaluate_method(24					context_creator.0(this.clone(), super_obj.clone())?,25					&b.value,26					args.clone()27				)))28			))),29		)30	} else {31		(32			b.name.clone(),33			lazy_binding!(move |this, super_obj| {34				Ok(lazy_val!(closure!(clone context_creator, clone b, ||35					push(b.value.clone(), "thunk".to_owned(), ||{36						evaluate(37							context_creator.0(this.clone(), super_obj.clone())?,38							&b.value39						)40					})41				)))42			}),43		)44	}45}4647pub fn evaluate_method(ctx: Context, expr: &LocExpr, arg_spec: ParamsDesc) -> Val {48	Val::Func(FuncDesc {49		ctx,50		params: arg_spec,51		eval_rhs: function_rhs!(closure!(clone expr, |ctx| evaluate(ctx, &expr))),52		eval_default: function_default!(closure!(|ctx, default| evaluate(ctx, &default))),53	})54}5556pub fn evaluate_field_name(57	context: Context,58	field_name: &jsonnet_parser::FieldName,59) -> Result<Option<String>> {60	Ok(match field_name {61		jsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),62		jsonnet_parser::FieldName::Dyn(expr) => {63			let value = evaluate(context, expr)?.unwrap_if_lazy()?;64			if matches!(value, Val::Null) {65				None66			} else {67				Some(value.try_cast_str("dynamic field name")?)68			}69		}70	})71}7273pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {74	Ok(match (op, b) {75		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,76		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),77		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),78		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),79		(op, o) => panic!("unary op not implemented: {:?} {:?}", op, o),80	})81}8283pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {84	Ok(match (a, b) {85		(Val::Str(v1), Val::Str(v2)) => Val::Str(v1.to_owned() + &v2),8687		(Val::Str(v1), Val::Num(v2)) => Val::Str(format!("{}{}", v1, v2)),88		(Val::Num(v1), Val::Str(v2)) => Val::Str(format!("{}{}", v1, v2)),89		(Val::Str(v1), Val::Bool(v2)) => Val::Str(format!("{}{}", v1, v2)),90		(Val::Bool(v1), Val::Str(v2)) => Val::Str(format!("{}{}", v1, v2)),91		(Val::Str(v1), Val::Null) => Val::Str(format!("{}null", v1)),92		(Val::Null, Val::Str(v2)) => Val::Str(format!("null{}", v2)),9394		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),95		(Val::Arr(a), Val::Arr(b)) => Val::Arr([&a[..], &b[..]].concat()),96		(Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),97		_ => panic!("can't add: {:?} and {:?}", a, b),98	})99}100101pub fn evaluate_binary_op_special(102	context: Context,103	a: &LocExpr,104	op: BinaryOpType,105	b: &LocExpr,106) -> Result<Val> {107	Ok(108		match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {109			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),110			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),111			(a, op, eb) => {112				evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?113			}114		},115	)116}117118pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {119	Ok(match (a, op, b) {120		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,121122		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize)),123124		// Bool X Bool125		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),126		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),127128		// Str X Str129		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),130		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),131		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),132		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),133134		// Num X Num135		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Num(v1 * v2),136		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => Val::Num(v1 / v2),137138		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::Num(v1 - v2),139140		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),141		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),142		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),143		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),144145		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {146			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)147		}148		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {149			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)150		}151		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {152			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)153		}154		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {155			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)156		}157		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {158			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)159		}160161		_ => panic!("no rules for binary operation: {:?} {:?} {:?}", a, op, b),162	})163}164165future_wrapper!(HashMap<String, LazyBinding>, FutureNewBindings);166future_wrapper!(ObjValue, FutureObjValue);167168pub fn evaluate_comp(169	context: Context,170	value: &LocExpr,171	specs: &[CompSpec],172) -> Result<Option<Vec<Val>>> {173	Ok(match specs.get(0) {174		None => Some(vec![evaluate(context, &value)?]),175		Some(CompSpec::IfSpec(IfSpecData(cond))) => {176			if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {177				evaluate_comp(context, value, &specs[1..])?178			} else {179				None180			}181		}182		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {183			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {184				Val::Arr(list) => {185					let mut out = Vec::new();186					for item in list {187						let item = item.clone().unwrap_if_lazy()?;188						out.push(evaluate_comp(189							context.with_var(var.clone(), item)?,190							value,191							&specs[1..],192						)?);193					}194					Some(out.iter().flatten().flatten().cloned().collect())195				}196				_ => panic!("for expression evaluated to non-iterable value"),197			}198		}199	})200}201202// TODO: Asserts203pub fn evaluate_object(context: Context, object: ObjBody) -> Result<ObjValue> {204	Ok(match object {205		ObjBody::MemberList(members) => {206			let new_bindings = FutureNewBindings::new();207			let future_this = FutureObjValue::new();208			let context_creator = context_creator!(209				closure!(clone context, clone new_bindings, clone future_this, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {210					Ok(context.clone().extend(211						new_bindings.clone().unwrap(),212						context.clone().dollar().clone().or_else(||this.clone()),213						Some(this.unwrap()),214						super_obj215					)?)216				})217			);218			{219				let mut bindings: HashMap<String, LazyBinding> = HashMap::new();220				for (n, b) in members221					.iter()222					.filter_map(|m| match m {223						Member::BindStmt(b) => Some(b.clone()),224						_ => None,225					})226					.map(|b| evaluate_binding(&b, context_creator.clone()))227				{228					bindings.insert(n, b);229				}230				new_bindings.fill(bindings);231			}232233			let mut new_members = BTreeMap::new();234			for member in members.into_iter() {235				match member {236					Member::Field(FieldMember {237						name,238						plus,239						params: None,240						visibility,241						value,242					}) => {243						let name = evaluate_field_name(context.clone(), &name)?;244						if name.is_none() {245							continue;246						}247						let name = name.unwrap();248						new_members.insert(249							name.clone(),250							ObjMember {251								add: plus,252								visibility: visibility.clone(),253								invoke: binding!(254									closure!(clone name, clone value, clone context_creator, |this, super_obj| {255										push(value.clone(), "object ".to_owned()+&name+" field", ||{256											let context = context_creator.0(this, super_obj)?;257											evaluate(258												context,259												&value,260											)?.unwrap_if_lazy()261										})262									})263								),264							},265						);266					}267					Member::Field(FieldMember {268						name,269						params: Some(params),270						value,271						..272					}) => {273						let name = evaluate_field_name(context.clone(), &name)?;274						if name.is_none() {275							continue;276						}277						let name = name.unwrap();278						new_members.insert(279							name,280							ObjMember {281								add: false,282								visibility: Visibility::Hidden,283								invoke: binding!(284									closure!(clone value, clone context_creator, |this, super_obj| {285										// TODO: Assert286										Ok(evaluate_method(287											context_creator.0(this, super_obj)?,288											&value.clone(),289											params.clone(),290										))291									})292								),293							},294						);295					}296					Member::BindStmt(_) => {}297					Member::AssertStmt(_) => {}298				}299			}300			future_this.fill(ObjValue::new(None, Rc::new(new_members)))301		}302		_ => todo!(),303	})304}305306pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {307	use Expr::*;308	let locexpr = expr.clone();309	let LocExpr(expr, loc) = expr;310	Ok(match &**expr {311		Literal(LiteralType::This) => Val::Obj(312			context313				.this()314				.clone()315				.unwrap_or_else(|| panic!("this not found")),316		),317		Literal(LiteralType::Dollar) => Val::Obj(318			context319				.dollar()320				.clone()321				.unwrap_or_else(|| panic!("dollar not found")),322		),323		Literal(LiteralType::True) => Val::Bool(true),324		Literal(LiteralType::False) => Val::Bool(false),325		Literal(LiteralType::Null) => Val::Null,326		Parened(e) => evaluate(context, e)?,327		Str(v) => Val::Str(v.clone()),328		Num(v) => Val::Num(*v),329		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,330		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,331		Var(name) => push(locexpr, "var".to_owned(), || {332			Val::Lazy(context.binding(&name)).unwrap_if_lazy()333		})?,334		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {335			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;336			context337				.super_obj()338				.clone()339				.expect("no super found")340				.get_raw(&name, &context.this().clone().expect("no this found"))?341				.expect("value not found")342		}343		Index(value, index) => {344			match (345				evaluate(context.clone(), value)?.unwrap_if_lazy()?,346				evaluate(context, index)?,347			) {348				(Val::Obj(v), Val::Str(s)) => {349					if let Some(v) = v.get(&s)? {350						v.unwrap_if_lazy()?351					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__")? {352						Val::Intristic(n, s)353					} else {354						create_error(crate::Error::NoSuchField(s))?355					}356				}357				(Val::Arr(v), Val::Num(n)) => v358					.get(n as usize)359					.unwrap_or_else(|| panic!("out of bounds"))360					.clone()361					.unwrap_if_lazy()?,362				(Val::Str(s), Val::Num(n)) => {363					Val::Str(s.chars().skip(n as usize).take(1).collect())364				}365				(v, i) => todo!("not implemented: {:?}[{:?}]", v, i.unwrap_if_lazy()),366			}367		}368		LocalExpr(bindings, returned) => {369			let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();370			let future_context = Context::new_future();371372			let context_creator = context_creator!(373				closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))374			);375376			for (k, v) in bindings377				.iter()378				.map(|b| evaluate_binding(b, context_creator.clone()))379			{380				new_bindings.insert(k, v);381			}382383			let context = context384				.extend(new_bindings, None, None, None)?385				.into_future(future_context);386			evaluate(context, &returned.clone())?387		}388		Arr(items) => {389			let mut out = Vec::with_capacity(items.len());390			for item in items {391				out.push(Val::Lazy(lazy_val!(392					closure!(clone context, clone item, || {393						evaluate(context.clone(), &item)394					})395				)));396			}397			Val::Arr(out)398		}399		ArrComp(expr, compspecs) => Val::Arr(400			// First compspec should be forspec, so no "None" possible here401			evaluate_comp(context, expr, compspecs)?.unwrap(),402		),403		Obj(body) => Val::Obj(evaluate_object(context, body.clone())?),404		ObjExtend(s, t) => evaluate_add_op(405			&evaluate(context.clone(), s)?,406			&Val::Obj(evaluate_object(context, t.clone())?),407		)?,408		Apply(value, ArgsDesc(args)) => {409			let value = evaluate(context.clone(), value)?.unwrap_if_lazy()?;410			match value {411				Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {412					// arr/string/function413					("std", "length") => {414						assert_eq!(args.len(), 1);415						let expr = &args.get(0).unwrap().1;416						match evaluate(context, expr)? {417							Val::Str(n) => Val::Num(n.chars().count() as f64),418							Val::Arr(i) => Val::Num(i.len() as f64),419							Val::Obj(o) => Val::Num(o.fields().len() as f64),420							v => panic!("can't get length of {:?}", v),421						}422					}423					// any424					("std", "type") => {425						assert_eq!(args.len(), 1);426						let expr = &args.get(0).unwrap().1;427						Val::Str(evaluate(context, expr)?.value_type()?.name().to_owned())428					}429					// length, idx=>any430					("std", "makeArray") => {431						assert_eq!(args.len(), 2);432						if let (Val::Num(v), Val::Func(d)) = (433							evaluate(context.clone(), &args[0].1)?,434							evaluate(context, &args[1].1)?,435						) {436							assert!(v >= 0.0);437							let mut out = Vec::with_capacity(v as usize);438							for i in 0..v as usize {439								out.push(d.evaluate(vec![(None, Val::Num(i as f64))])?)440							}441							Val::Arr(out)442						} else {443							panic!("bad makeArray call");444						}445					}446					// string447					("std", "codepoint") => {448						assert_eq!(args.len(), 1);449						if let Val::Str(s) = evaluate(context, &args[0].1)? {450							assert!(451								s.chars().count() == 1,452								"std.codepoint should receive single char string"453							);454							Val::Num(s.chars().take(1).next().unwrap() as u32 as f64)455						} else {456							panic!("bad codepoint call");457						}458					}459					// object, includeHidden460					("std", "objectFieldsEx") => {461						assert_eq!(args.len(), 2);462						if let (Val::Obj(body), Val::Bool(_include_hidden)) = (463							evaluate(context.clone(), &args[0].1)?,464							evaluate(context, &args[1].1)?,465						) {466							// TODO: handle visibility (_include_hidden)467							Val::Arr(body.fields().into_iter().map(Val::Str).collect())468						} else {469							panic!("bad objectFieldsEx call");470						}471					}472					("std", "primitiveEquals") => {473						assert_eq!(args.len(), 2);474						let (a, b) = (475							evaluate(context.clone(), &args[0].1)?,476							evaluate(context, &args[1].1)?,477						);478						Val::Bool(a == b)479					}480					("std", "modulo") => {481						assert_eq!(args.len(), 2);482						if let (Val::Num(a), Val::Num(b)) = (483							evaluate(context.clone(), &args[0].1)?,484							evaluate(context, &args[1].1)?,485						) {486							Val::Num(a % b)487						} else {488							panic!("bad modulo call");489						}490					}491					("std", "floor") => {492						assert_eq!(args.len(), 1);493						if let Val::Num(a) = evaluate(context, &args[0].1)? {494							Val::Num(a.floor())495						} else {496							panic!("bad floor call");497						}498					}499					("std", "trace") => {500						assert_eq!(args.len(), 2);501						if let (Val::Str(a), b) = (502							evaluate(context.clone(), &args[0].1)?,503							evaluate(context, &args[1].1)?,504						) {505							println!("{}", a);506							b507						} else {508							panic!("bad trace call");509						}510					}511					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),512				},513				Val::Func(f) => push(locexpr, "function call".to_owned(), || {514					f.evaluate(515						args.clone()516							.into_iter()517							.map(move |a| {518								(519									a.clone().0,520									Val::Lazy(lazy_val!(521										closure!(clone context, clone a, || evaluate(context.clone(), &a.clone().1))522									)),523								)524							})525							.collect(),526					)527				})?,528				_ => panic!("{:?} is not a function", value),529			}530		}531		Function(params, body) => evaluate_method(context, body, params.clone()),532		AssertExpr(AssertStmt(value, msg), returned) => {533			let assertion_result = push(value.clone(), "assertion condition".to_owned(), || {534				evaluate(context.clone(), &value)?535					.try_cast_bool("assertion condition should be boolean")536			})?;537			if assertion_result {538				push(539					returned.clone(),540					"assert 'return' branch".to_owned(),541					|| evaluate(context, returned),542				)?543			} else if let Some(msg) = msg {544				panic!(545					"assertion failed ({:?}): {}",546					value,547					evaluate(context, msg)?.try_cast_str("assertion message should be string")?548				);549			} else {550				panic!("assertion failed ({:?}): no message", value);551			}552		}553		Error(e) => create_error(crate::Error::RuntimeError(554			evaluate(context, e)?.try_cast_str("error text should be string")?,555		))?,556		IfElse {557			cond,558			cond_then,559			cond_else,560		} => {561			let condition_result = push(cond.0.clone(), "if condition".to_owned(), || {562				evaluate(context.clone(), &cond.0)?.try_cast_bool("if condition should be boolean")563			})?;564			if condition_result {565				push(566					cond_then.clone(),567					"if condition 'then' branch".to_owned(),568					|| evaluate(context, cond_then),569				)?570			} else {571				match cond_else {572					Some(v) => push(v.clone(), "if condition 'else' branch".to_owned(), || {573						evaluate(context, v)574					})?,575					None => Val::Null,576				}577			}578		}579		_ => panic!(580			"evaluation not implemented: {:?}",581			LocExpr(expr.clone(), loc.clone())582		),583	})584}