git.delta.rocks / jrsonnet / refs/commits / fab41c8db644

1use crate::{2	binding, bool_val, context_creator, function_default, function_rhs, future_wrapper,3	lazy_binding, lazy_val, Context, ContextCreator, EvaluationState, FuncDesc, LazyBinding,4	ObjMember, ObjValue, Val,5};6use closure::closure;7use jsonnet_parser::{8	el, Arg, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember,9	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,10	Visibility,11};12use std::{13	collections::{BTreeMap, HashMap},14	rc::Rc,15};1617pub fn evaluate_binding(18	eval_state: EvaluationState,19	b: &BindSpec,20	context_creator: ContextCreator,21) -> (String, LazyBinding) {22	let b = b.clone();23	if let Some(args) = &b.params {24		let args = args.clone();25		(26			b.name.clone(),27			lazy_binding!(move |this, super_obj| lazy_val!(28				closure!(clone b, clone args, clone context_creator, clone eval_state, || evaluate_method(29					context_creator.0(this.clone(), super_obj.clone()),30					eval_state.clone(),31					&b.value,32					args.clone()33				))34			)),35		)36	} else {37		(38			b.name.clone(),39			lazy_binding!(move |this, super_obj| {40				lazy_val!(41					closure!(clone context_creator, clone b, clone eval_state, || evaluate(42						context_creator.0(this.clone(), super_obj.clone()),43						eval_state.clone(),44						&b.value45					))46				)47			}),48		)49	}50}5152pub fn evaluate_method(53	ctx: Context,54	eval_state: EvaluationState,55	expr: &LocExpr,56	arg_spec: ParamsDesc,57) -> Val {58	Val::Func(FuncDesc {59		ctx,60		params: arg_spec,61		eval_rhs: function_rhs!(62			closure!(clone expr, clone eval_state, |ctx| evaluate(ctx, eval_state.clone(), &expr))63		),64		eval_default: function_default!(65			closure!(clone eval_state, |ctx, default| evaluate(ctx, eval_state.clone(), &default))66		),67	})68}6970pub fn evaluate_field_name(71	context: Context,72	eval_state: EvaluationState,73	field_name: &jsonnet_parser::FieldName,74) -> String {75	match field_name {76		jsonnet_parser::FieldName::Fixed(n) => n.clone(),77		jsonnet_parser::FieldName::Dyn(expr) => {78			let name = evaluate(context, eval_state, expr).unwrap_if_lazy();79			match name {80				Val::Str(n) => n,81				_ => panic!(82					"dynamic field name can be only evaluated to 'string', got: {:?}",83					name84				),85			}86		}87	}88}8990pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Val {91	match (op, b) {92		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()),93		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),94		(op, o) => panic!("unary op not implemented: {:?} {:?}", op, o),95	}96}9798pub fn evaluate_add_op(a: &Val, b: &Val) -> Val {99	match (a, b) {100		(Val::Str(v1), Val::Str(v2)) => Val::Str(v1.to_owned() + &v2),101		(Val::Str(v1), Val::Num(v2)) => Val::Str(format!("{}{}", v1, v2)),102		(Val::Num(v1), Val::Str(v2)) => Val::Str(format!("{}{}", v1, v2)),103		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),104		(Val::Arr(a), Val::Arr(b)) => Val::Arr([&a[..], &b[..]].concat()),105		(Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),106		_ => panic!("can't add: {:?} and {:?}", a, b),107	}108}109110pub fn evaluate_binary_op(111	context: Context,112	eval_state: EvaluationState,113	a: &Val,114	op: BinaryOpType,115	b: &Val,116) -> Val {117	match (a, op, b) {118		(Val::Lazy(a), o, b) => evaluate_binary_op(context, eval_state, &a.evaluate(), o, b),119		(a, o, Val::Lazy(b)) => evaluate_binary_op(context, eval_state, a, o, &b.evaluate()),120121		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b),122123		(Val::Str(v1), BinaryOpType::Ne, Val::Str(v2)) => bool_val(v1 != v2),124125		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize)),126		(Val::Str(format), BinaryOpType::Mod, args) => evaluate(127			context128				.with_var("__tmp__format__".to_owned(), Val::Str(format.to_owned()))129				.with_var(130					"__tmp__args__".to_owned(),131					match args {132						Val::Arr(v) => Val::Arr(v.clone()),133						v => Val::Arr(vec![v.clone()]),134					},135				),136			eval_state,137			&el!(Expr::Apply(138				el!(Expr::Index(139					el!(Expr::Var("std".to_owned())),140					el!(Expr::Str("format".to_owned()))141				)),142				ArgsDesc(vec![143					Arg(None, el!(Expr::Var("__tmp__format__".to_owned()))),144					Arg(None, el!(Expr::Var("__tmp__args__".to_owned())))145				])146			)),147		),148149		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),150		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),151152		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Num(v1 * v2),153		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => Val::Num(v1 / v2),154		(Val::Num(v1), BinaryOpType::Mod, Val::Num(v2)) => Val::Num(v1 % v2),155156		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::Num(v1 - v2),157158		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {159			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)160		}161		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {162			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)163		}164165		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => bool_val(v1 < v2),166		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => bool_val(v1 > v2),167		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => bool_val(v1 <= v2),168		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => bool_val(v1 >= v2),169170		(Val::Num(v1), BinaryOpType::Eq, Val::Num(v2)) => bool_val((v1 - v2).abs() < f64::EPSILON),171		(Val::Num(v1), BinaryOpType::Ne, Val::Num(v2)) => bool_val((v1 - v2).abs() > f64::EPSILON),172173		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {174			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)175		}176		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {177			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)178		}179		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {180			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)181		}182		(a, BinaryOpType::Eq, b) => bool_val(a == b),183		(a, BinaryOpType::Ne, b) => bool_val(a != b),184		_ => panic!("no rules for binary operation: {:?} {:?} {:?}", a, op, b),185	}186}187188future_wrapper!(HashMap<String, LazyBinding>, FutureNewBindings);189future_wrapper!(ObjValue, FutureObjValue);190191pub fn evaluate_comp(192	context: Context,193	eval_state: EvaluationState,194	value: &LocExpr,195	specs: &[CompSpec],196) -> Option<Vec<Val>> {197	match specs.get(0) {198		None => Some(vec![evaluate(context, eval_state, &value)]),199		Some(CompSpec::IfSpec(IfSpecData(cond))) => {200			match evaluate(context.clone(), eval_state.clone(), &cond).unwrap_if_lazy() {201				Val::Bool(false) => None,202				Val::Bool(true) => evaluate_comp(context, eval_state, value, &specs[1..]),203				_ => panic!("if expression evaluated to non-boolean value"),204			}205		}206		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {207			match evaluate(context.clone(), eval_state.clone(), &expr).unwrap_if_lazy() {208				Val::Arr(list) => {209					let mut out = Vec::new();210					for item in list {211						let item = item.clone();212						out.push(evaluate_comp(213							context.with_var(var.clone(), item),214							eval_state.clone(),215							value,216							&specs[1..],217						));218					}219					Some(out.iter().flatten().flatten().cloned().collect())220				}221				_ => panic!("for expression evaluated to non-iterable value"),222			}223		}224	}225}226227// TODO: Asserts228pub fn evaluate_object(context: Context, eval_state: EvaluationState, object: ObjBody) -> ObjValue {229	match object {230		ObjBody::MemberList(members) => {231			let new_bindings = FutureNewBindings::new();232			let future_this = FutureObjValue::new();233			let context_creator = context_creator!(234				closure!(clone context, clone new_bindings, clone future_this, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {235					context.clone().extend(236						new_bindings.clone().unwrap(),237						context.clone().dollar().clone().or_else(||this.clone()),238						Some(this.unwrap()),239						super_obj240					)241				})242			);243			{244				let mut bindings: HashMap<String, LazyBinding> = HashMap::new();245				for (n, b) in members246					.iter()247					.filter_map(|m| match m {248						Member::BindStmt(b) => Some(b.clone()),249						_ => None,250					})251					.map(|b| evaluate_binding(eval_state.clone(), &b, context_creator.clone()))252				{253					bindings.insert(n, b);254				}255				new_bindings.fill(bindings);256			}257258			let mut new_members = BTreeMap::new();259			for member in members.into_iter() {260				match member {261					Member::Field(FieldMember {262						name,263						plus,264						params: None,265						visibility,266						value,267					}) => {268						let name = evaluate_field_name(context.clone(), eval_state.clone(), &name);269						new_members.insert(270							name,271							ObjMember {272								add: plus,273								visibility: visibility.clone(),274								invoke: binding!(275									closure!(clone value, clone context_creator, clone eval_state, |this, super_obj| {276										let context = context_creator.0(this, super_obj);277										// TODO: Assert278										evaluate(279											context,280											eval_state.clone(),281											&value,282										).unwrap_if_lazy()283									})284								),285							},286						);287					}288					Member::Field(FieldMember {289						name,290						params: Some(params),291						value,292						..293					}) => {294						let name = evaluate_field_name(context.clone(), eval_state.clone(), &name);295						new_members.insert(296							name,297							ObjMember {298								add: false,299								visibility: Visibility::Hidden,300								invoke: binding!(301									closure!(clone value, clone context_creator, clone eval_state, |this, super_obj| {302										// TODO: Assert303										evaluate_method(304											context_creator.0(this, super_obj),305											eval_state.clone(),306											&value.clone(),307											params.clone(),308										)309									})310								),311							},312						);313					}314					Member::BindStmt(_) => {}315					Member::AssertStmt(_) => {}316				}317			}318			future_this.fill(ObjValue::new(None, Rc::new(new_members)))319		}320		_ => todo!(),321	}322}323324pub fn evaluate(context: Context, eval_state: EvaluationState, expr: &LocExpr) -> Val {325	use Expr::*;326	eval_state.clone().push(expr.clone(), "expr".to_owned(), || {327		let LocExpr(expr, loc) = expr;328		match &**expr {329			Literal(LiteralType::This) => Val::Obj(330				context331					.this()332					.clone()333					.unwrap_or_else(|| panic!("this not found")),334			),335			Literal(LiteralType::Super) => Val::Obj(336				context337					.super_obj()338					.clone()339					.unwrap_or_else(|| panic!("super not found")),340			),341			Literal(LiteralType::True) => Val::Bool(true),342			Literal(LiteralType::False) => Val::Bool(false),343			Literal(LiteralType::Null) => Val::Null,344			Parened(e) => evaluate(context, eval_state.clone(), e),345			Str(v) => Val::Str(v.clone()),346			Num(v) => Val::Num(*v),347			BinaryOp(v1, o, v2) => {348				let a = evaluate(context.clone(), eval_state.clone(), v1).unwrap_if_lazy();349				let op = *o;350				let b = evaluate(context.clone(), eval_state.clone(), v2).unwrap_if_lazy();351				evaluate_binary_op(352					context,353					eval_state,354					&a,355					op,356					&b,357				)358			},359			UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, eval_state, v)),360			Var(name) => Val::Lazy(context.binding(&name)).unwrap_if_lazy(),361			Index(value, index) => {362				match (363					evaluate(context.clone(), eval_state.clone(), value).unwrap_if_lazy(),364					evaluate(context.clone(), eval_state.clone(), index),365				) {366					(Val::Obj(v), Val::Str(s)) => v367						.get(&s)368						.unwrap_or_else(closure!(clone context, clone eval_state, || {369							if let Some(n) = v.get("__intristic_namespace__") {370								if let Val::Str(n) = n.unwrap_if_lazy() {371									Val::Intristic(n, s)372								} else {373									panic!("__intristic_namespace__ should be string");374								}375							} else {376								panic!("{} not found in {:?}", s, v)377							}378						}))379						.unwrap_if_lazy(),380					(Val::Arr(v), Val::Num(n)) => v381						.get(n as usize)382						.unwrap_or_else(|| panic!("out of bounds"))383						.clone(),384					(Val::Str(s), Val::Num(n)) => {385						Val::Str(s.chars().skip(n as usize).take(1).collect())386					}387					(v, i) => todo!("not implemented: {:?}[{:?}]", v, i.unwrap_if_lazy()),388				}389			}390			LocalExpr(bindings, returned) => {391				let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();392				let future_context = Context::new_future();393394				let context_creator = context_creator!(395					closure!(clone future_context, |_, _| future_context.clone().unwrap())396				);397398				for (k, v) in bindings399					.iter()400					.map(|b| evaluate_binding(eval_state.clone(), b, context_creator.clone()))401				{402					new_bindings.insert(k, v);403				}404405				let context = context406					.extend(new_bindings, None, None, None)407					.into_future(future_context);408				evaluate(context, eval_state.clone(), &returned.clone())409			}410			Arr(items) => {411				let mut out = Vec::with_capacity(items.len());412				for item in items {413					out.push(evaluate(context.clone(), eval_state.clone(), item));414				}415				Val::Arr(out)416			}417			ArrComp(expr, compspecs) => {418				Val::Arr(evaluate_comp(context, eval_state, expr, compspecs).unwrap())419			}420			Obj(body) => Val::Obj(evaluate_object(context, eval_state, body.clone())),421			Apply(value, ArgsDesc(args)) => {422				let value = evaluate(context.clone(), eval_state.clone(), value).unwrap_if_lazy();423				match value {424					// TODO: Capture context of application425					Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {426						// arr/string/function427						("std", "length") => {428							assert_eq!(args.len(), 1);429							let expr = &args.get(0).unwrap().1;430							match evaluate(context, eval_state.clone(), expr) {431								Val::Str(n) => Val::Num(n.chars().count() as f64),432								Val::Arr(i) => Val::Num(i.len() as f64),433								v => panic!("can't get length of {:?}", v),434							}435						}436						// any437						("std", "type") => {438							assert_eq!(args.len(), 1);439							let expr = &args.get(0).unwrap().1;440							Val::Str(evaluate(context, eval_state, expr).type_of().to_owned())441						}442						// length, idx=>any443						("std", "makeArray") => {444							assert_eq!(args.len(), 2);445							if let (Val::Num(v), Val::Func(d)) = (446								evaluate(context.clone(), eval_state.clone(), &args[0].1),447								evaluate(context, eval_state, &args[1].1),448							) {449								assert!(v > 0.0);450								let mut out = Vec::with_capacity(v as usize);451								for i in 0..v as usize {452									out.push(d.evaluate(vec![(None, Val::Num(i as f64))]))453								}454								Val::Arr(out)455							} else {456								panic!("bad makeArray call");457							}458						}459						// string460						("std", "codepoint") => {461							assert_eq!(args.len(), 1);462							if let Val::Str(s) = evaluate(context, eval_state, &args[0].1) {463								assert!(464									s.chars().count() == 1,465									"std.codepoint should receive single char string"466								);467								Val::Num(s.chars().take(1).next().unwrap() as u32 as f64)468							} else {469								panic!("bad codepoint call");470							}471						}472						// object, includeHidden473						("std", "objectFieldsEx") => {474							assert_eq!(args.len(), 2);475							if let (Val::Obj(body), Val::Bool(_include_hidden)) = (476								evaluate(context.clone(), eval_state.clone(), &args[0].1),477								evaluate(context, eval_state, &args[1].1),478							) {479								// TODO: handle visibility (_include_hidden)480								Val::Arr(body.fields().into_iter().map(Val::Str).collect())481							} else {482								panic!("bad objectFieldsEx call");483							}484						}485						(ns, name) => panic!("Intristic not found: {}.{}", ns, name),486					},487					Val::Func(f) => f.evaluate(488						args.clone()489							.into_iter()490							.map(move |a| {491								(492									a.clone().0,493									Val::Lazy(lazy_val!(494										closure!(clone context, clone a, clone eval_state, || evaluate(context.clone(), eval_state.clone(), &a.clone().1))495									)),496								)497							})498							.collect(),499					),500					_ => panic!("{:?} is not a function", value),501				}502			}503			Function(params, body) => evaluate_method(context, eval_state, body, params.clone()),504			AssertExpr(AssertStmt(value, msg), returned) => {505				if evaluate(context.clone(), eval_state.clone(), &value).try_cast_bool() {506					evaluate(context, eval_state, returned)507				}else {508					if let Some(msg) = msg {509						panic!("assertion failed ({:?}): {}", value, evaluate(context, eval_state, msg).try_cast_str());510					} else {511						panic!("assertion failed ({:?}): no message", value);512					}513				}514			},515			Error(e) => panic!("error: {}", evaluate(context, eval_state, e)),516			IfElse {517				cond,518				cond_then,519				cond_else,520			} => match evaluate(context.clone(), eval_state.clone(), &cond.0).unwrap_if_lazy() {521				Val::Bool(true) => evaluate(context, eval_state.clone(), cond_then),522				Val::Bool(false) => match cond_else {523					Some(v) => evaluate(context, eval_state, v),524					None => Val::Bool(false),525				},526				v => panic!("if condition evaluated to {:?} (boolean needed instead)", v),527			},528			_ => panic!(529				"evaluation not implemented: {:?}",530				LocExpr(expr.clone(), loc.clone())531			),532		}533	})534}