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

1use crate::{2	equals, error::Error::*, lazy_val, push, throw, with_state, ArrValue, Context, ContextCreator,3	FuncDesc, FuncVal, FutureWrapper, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,4};5use closure::closure;6use jrsonnet_interner::IStr;7use jrsonnet_parser::{8	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,9	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,10	Visibility,11};12use jrsonnet_types::ValType;13use rustc_hash::{FxHashMap, FxHasher};14use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};1516pub fn evaluate_binding_in_future(17	b: &BindSpec,18	context_creator: FutureWrapper<Context>,19) -> LazyVal {20	let b = b.clone();21	if let Some(params) = &b.params {22		let params = params.clone();23		LazyVal::new(Box::new(move || {24			Ok(evaluate_method(25				context_creator.unwrap(),26				b.name.clone(),27				params.clone(),28				b.value.clone(),29			))30		}))31	} else {32		LazyVal::new(Box::new(move || {33			evaluate_named(context_creator.unwrap(), &b.value, b.name.clone())34		}))35	}36}3738pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {39	let b = b.clone();40	if let Some(params) = &b.params {41		let params = params.clone();42		(43			b.name.clone(),44			LazyBinding::Bindable(Rc::new(move |this, super_obj| {45				Ok(lazy_val!(46					closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(47						context_creator.create(this.clone(), super_obj.clone())?,48						b.name.clone(),49						params.clone(),50						b.value.clone(),51					)))52				))53			})),54		)55	} else {56		(57			b.name.clone(),58			LazyBinding::Bindable(Rc::new(move |this, super_obj| {59				Ok(lazy_val!(closure!(clone context_creator, clone b, ||60					evaluate_named(61						context_creator.create(this.clone(), super_obj.clone())?,62						&b.value,63						b.name.clone()64					)65				)))66			})),67		)68	}69}7071pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {72	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {73		name,74		ctx,75		params,76		body,77	})))78}7980pub fn evaluate_field_name(81	context: Context,82	field_name: &jrsonnet_parser::FieldName,83) -> Result<Option<IStr>> {84	Ok(match field_name {85		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),86		jrsonnet_parser::FieldName::Dyn(expr) => {87			let value = evaluate(context, expr)?;88			if matches!(value, Val::Null) {89				None90			} else {91				Some(value.try_cast_str("dynamic field name")?)92			}93		}94	})95}9697pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {98	Ok(match (op, b) {99		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),100		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),101		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),102		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),103	})104}105106pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {107	Ok(match (a, b) {108		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),109110		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)111		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),112		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),113114		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().to_string()?).into()),115		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),116117		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.extend_from(v1.clone())),118		(Val::Arr(a), Val::Arr(b)) => {119			let mut out = Vec::with_capacity(a.len() + b.len());120			out.extend(a.iter_lazy());121			out.extend(b.iter_lazy());122			Val::Arr(out.into())123		}124		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,125		_ => throw!(BinaryOperatorDoesNotOperateOnValues(126			BinaryOpType::Add,127			a.value_type(),128			b.value_type(),129		)),130	})131}132133pub fn evaluate_binary_op_special(134	context: Context,135	a: &LocExpr,136	op: BinaryOpType,137	b: &LocExpr,138) -> Result<Val> {139	Ok(match (evaluate(context.clone(), a)?, op, b) {140		(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),141		(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),142		(a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,143	})144}145146pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {147	Ok(match (a, op, b) {148		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,149150		(a, BinaryOpType::Eq, b) => Val::Bool(equals(&a, &b)?),151		(a, BinaryOpType::Neq, b) => Val::Bool(!equals(&a, &b)?),152153		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),154155		// Bool X Bool156		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),157		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),158159		// Str X Str160		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),161		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),162		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),163		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),164165		// Num X Num166		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,167		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {168			if *v2 <= f64::EPSILON {169				throw!(DivisionByZero)170			}171			Val::new_checked_num(v1 / v2)?172		}173174		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,175176		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),177		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),178		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),179		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),180181		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {182			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)183		}184		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {185			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)186		}187		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {188			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)189		}190		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {191			if *v2 < 0.0 {192				throw!(RuntimeError("shift by negative exponent".into()))193			}194			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)195		}196		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {197			if *v2 < 0.0 {198				throw!(RuntimeError("shift by negative exponent".into()))199			}200			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)201		}202203		_ => throw!(BinaryOperatorDoesNotOperateOnValues(204			op,205			a.value_type(),206			b.value_type(),207		)),208	})209}210211pub fn evaluate_comp(212	context: Context,213	specs: &[CompSpec],214	callback: &mut impl FnMut(Context) -> Result<()>,215) -> Result<()> {216	match specs.get(0) {217		None => callback(context)?,218		Some(CompSpec::IfSpec(IfSpecData(cond))) => {219			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {220				evaluate_comp(context, &specs[1..], callback)?221			}222		}223		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {224			Val::Arr(list) => {225				for item in list.iter() {226					evaluate_comp(227						context.clone().with_var(var.clone(), item?.clone()),228						&specs[1..],229						callback,230					)?231				}232			}233			_ => throw!(InComprehensionCanOnlyIterateOverArray),234		},235	}236	Ok(())237}238239pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {240	let new_bindings = FutureWrapper::new();241	let future_this = FutureWrapper::new();242	let context_creator = ContextCreator(context.clone(), new_bindings.clone());243	{244		let mut bindings: FxHashMap<IStr, LazyBinding> =245			FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());246		for (n, b) in members247			.iter()248			.filter_map(|m| match m {249				Member::BindStmt(b) => Some(b.clone()),250				_ => None,251			})252			.map(|b| evaluate_binding(&b, context_creator.clone()))253		{254			bindings.insert(n, b);255		}256		new_bindings.fill(bindings);257	}258259	let mut new_members = FxHashMap::default();260	let mut assertions = Vec::new();261	for member in members.iter() {262		match member {263			Member::Field(FieldMember {264				name,265				plus,266				params: None,267				visibility,268				value,269			}) => {270				let name = evaluate_field_name(context.clone(), name)?;271				if name.is_none() {272					continue;273				}274				let name = name.unwrap();275				new_members.insert(276					name.clone(),277					ObjMember {278						add: *plus,279						visibility: *visibility,280						invoke: LazyBinding::Bindable(Rc::new(281							closure!(clone name, clone value, clone context_creator, |this, super_obj| {282								Ok(LazyVal::new_resolved(evaluate_named(283									context_creator.create(this, super_obj)?,284									&value,285									name.clone(),286								)?))287							}),288						)),289						location: value.1.clone(),290					},291				);292			}293			Member::Field(FieldMember {294				name,295				params: Some(params),296				value,297				..298			}) => {299				let name = evaluate_field_name(context.clone(), name)?;300				if name.is_none() {301					continue;302				}303				let name = name.unwrap();304				new_members.insert(305					name.clone(),306					ObjMember {307						add: false,308						visibility: Visibility::Hidden,309						invoke: LazyBinding::Bindable(Rc::new(310							closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {311								// TODO: Assert312								Ok(LazyVal::new_resolved(evaluate_method(313									context_creator.create(this, super_obj)?,314									name.clone(),315									params.clone(),316									value.clone(),317								)))318							}),319						)),320						location: value.1.clone(),321					},322				);323			}324			Member::BindStmt(_) => {}325			Member::AssertStmt(stmt) => {326				assertions.push(stmt.clone());327			}328		}329	}330	let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(assertions));331	future_this.fill(this.clone());332	Ok(this)333}334335pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {336	Ok(match object {337		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,338		ObjBody::ObjComp(obj) => {339			let future_this = FutureWrapper::new();340			let mut new_members = FxHashMap::default();341			evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {342				let new_bindings = FutureWrapper::new();343				let context_creator = ContextCreator(context.clone(), new_bindings.clone());344				let mut bindings: FxHashMap<IStr, LazyBinding> =345					FxHashMap::with_capacity_and_hasher(346						obj.pre_locals.len() + obj.post_locals.len(),347						BuildHasherDefault::default(),348					);349				for (n, b) in obj350					.pre_locals351					.iter()352					.chain(obj.post_locals.iter())353					.map(|b| evaluate_binding(b, context_creator.clone()))354				{355					bindings.insert(n, b);356				}357				new_bindings.fill(bindings.clone());358				let ctx = ctx.extend_unbound(bindings, None, None, None)?;359				let key = evaluate(ctx.clone(), &obj.key)?;360361				match key {362					Val::Null => {}363					Val::Str(n) => {364						new_members.insert(365							n,366							ObjMember {367								add: false,368								visibility: Visibility::Normal,369								invoke: LazyBinding::Bindable(Rc::new(370									closure!(clone ctx, clone obj.value, |this, _super_obj| {371										Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))372									}),373								)),374								location: obj.value.1.clone(),375							},376						);377					}378					v => throw!(FieldMustBeStringGot(v.value_type())),379				}380381				Ok(())382			})?;383384			let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(Vec::new()));385			future_this.fill(this.clone());386			this387		}388	})389}390391pub fn evaluate_apply(392	context: Context,393	value: &LocExpr,394	args: &ArgsDesc,395	loc: Option<&ExprLocation>,396	tailstrict: bool,397) -> Result<Val> {398	let value = evaluate(context.clone(), value)?;399	Ok(match value {400		Val::Func(f) => {401			let body = || f.evaluate(context, loc, args, tailstrict);402			if tailstrict {403				body()?404			} else {405				push(loc, || format!("function <{}> call", f.name()), body)?406			}407		}408		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),409	})410}411412pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {413	let value = &assertion.0;414	let msg = &assertion.1;415	let assertion_result = push(416		value.1.as_ref(),417		|| "assertion condition".to_owned(),418		|| {419			evaluate(context.clone(), value)?420				.try_cast_bool("assertion condition should be of type `boolean`")421		},422	)?;423	if !assertion_result {424		push(425			value.1.as_ref(),426			|| "assertion failure".to_owned(),427			|| {428				if let Some(msg) = msg {429					throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));430				} else {431					throw!(AssertionFailed(Val::Null.to_string()?));432				}433			},434		)?435	}436	Ok(())437}438439pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {440	use Expr::*;441	let LocExpr(expr, _loc) = lexpr;442	Ok(match &**expr {443		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),444		_ => evaluate(context, lexpr)?,445	})446}447448pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {449	use Expr::*;450	let LocExpr(expr, loc) = expr;451	Ok(match &**expr {452		Literal(LiteralType::This) => {453			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)454		}455		Literal(LiteralType::Super) => Val::Obj(456			context457				.super_obj()458				.clone()459				.ok_or(NoSuperFound)?460				.with_this(context.this().clone().unwrap()),461		),462		Literal(LiteralType::Dollar) => {463			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)464		}465		Literal(LiteralType::True) => Val::Bool(true),466		Literal(LiteralType::False) => Val::Bool(false),467		Literal(LiteralType::Null) => Val::Null,468		Parened(e) => evaluate(context, e)?,469		Str(v) => Val::Str(v.clone()),470		Num(v) => Val::new_checked_num(*v)?,471		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,472		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,473		Var(name) => push(474			loc.as_ref(),475			|| format!("variable <{}>", name),476			|| context.binding(name.clone())?.evaluate(),477		)?,478		Index(value, index) => {479			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {480				(Val::Obj(v), Val::Str(s)) => {481					let sn = s.clone();482					push(483						loc.as_ref(),484						|| format!("field <{}> access", sn),485						|| {486							if let Some(v) = v.get(s.clone())? {487								Ok(v)488							} else if v.get("__intrinsic_namespace__".into())?.is_some() {489								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))490							} else {491								throw!(NoSuchField(s))492							}493						},494					)?495				}496				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(497					ValType::Obj,498					ValType::Str,499					n.value_type(),500				)),501502				(Val::Arr(v), Val::Num(n)) => {503					if n.fract() > f64::EPSILON {504						throw!(FractionalIndex)505					}506					v.get(n as usize)?507						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?508				}509				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),510				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(511					ValType::Arr,512					ValType::Num,513					n.value_type(),514				)),515516				(Val::Str(s), Val::Num(n)) => Val::Str(517					s.chars()518						.skip(n as usize)519						.take(1)520						.collect::<String>()521						.into(),522				),523				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(524					ValType::Str,525					ValType::Num,526					n.value_type(),527				)),528529				(v, _) => throw!(CantIndexInto(v.value_type())),530			}531		}532		LocalExpr(bindings, returned) => {533			let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(534				bindings.len(),535				BuildHasherDefault::<FxHasher>::default(),536			);537			let future_context = Context::new_future();538			for b in bindings {539				new_bindings.insert(540					b.name.clone(),541					evaluate_binding_in_future(b, future_context.clone()),542				);543			}544			let context = context545				.extend_bound(new_bindings)546				.into_future(future_context);547			evaluate(context, &returned.clone())?548		}549		Arr(items) => {550			let mut out = Vec::with_capacity(items.len());551			for item in items {552				out.push(LazyVal::new(Box::new(553					closure!(clone context, clone item, || {554						evaluate(context.clone(), &item)555					}),556				)));557			}558			Val::Arr(out.into())559		}560		ArrComp(expr, comp_specs) => {561			let mut out = Vec::new();562			evaluate_comp(context, comp_specs, &mut |ctx| {563				out.push(evaluate(ctx, expr)?);564				Ok(())565			})?;566			Val::Arr(ArrValue::Eager(Rc::new(out)))567		}568		Obj(body) => Val::Obj(evaluate_object(context, body)?),569		ObjExtend(s, t) => evaluate_add_op(570			&evaluate(context.clone(), s)?,571			&Val::Obj(evaluate_object(context, t)?),572		)?,573		Apply(value, args, tailstrict) => {574			evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?575		}576		Function(params, body) => {577			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())578		}579		Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),580		AssertExpr(assert, returned) => {581			evaluate_assert(context.clone(), &assert)?;582			evaluate(context, returned)?583		}584		ErrorStmt(e) => push(585			loc.as_ref(),586			|| "error statement".to_owned(),587			|| {588				throw!(RuntimeError(589					evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,590				))591			},592		)?,593		IfElse {594			cond,595			cond_then,596			cond_else,597		} => {598			if push(599				loc.as_ref(),600				|| "if condition".to_owned(),601				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),602			)? {603				evaluate(context, cond_then)?604			} else {605				match cond_else {606					Some(v) => evaluate(context, v)?,607					None => Val::Null,608				}609			}610		}611		Import(path) => {612			let mut tmp = loc613				.clone()614				.expect("imports cannot be used without loc_data")615				.0;616			let import_location = Rc::make_mut(&mut tmp);617			import_location.pop();618			push(619				loc.as_ref(),620				|| format!("import {:?}", path),621				|| with_state(|s| s.import_file(import_location, path)),622			)?623		}624		ImportStr(path) => {625			let mut tmp = loc626				.clone()627				.expect("imports cannot be used without loc_data")628				.0;629			let import_location = Rc::make_mut(&mut tmp);630			import_location.pop();631			Val::Str(with_state(|s| s.import_file_str(import_location, path))?)632		}633	})634}