git.delta.rocks / jrsonnet / refs/commits / 959933eb18e2

1use crate::{2	error::Error::*, lazy_val, push, throw, with_state, Context, ContextCreator, FuncDesc, FuncVal,3	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		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),151152		// Bool X Bool153		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),154		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),155156		// Str X Str157		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),158		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),159		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),160		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),161162		// Num X Num163		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,164		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {165			if *v2 <= f64::EPSILON {166				throw!(DivisionByZero)167			}168			Val::new_checked_num(v1 / v2)?169		}170171		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,172173		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),174		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),175		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),176		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),177178		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {179			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)180		}181		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {182			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)183		}184		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {185			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)186		}187		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {188			if *v2 < 0.0 {189				throw!(RuntimeError("shift by negative exponent".into()))190			}191			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)192		}193		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {194			if *v2 < 0.0 {195				throw!(RuntimeError("shift by negative exponent".into()))196			}197			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)198		}199200		_ => throw!(BinaryOperatorDoesNotOperateOnValues(201			op,202			a.value_type(),203			b.value_type(),204		)),205	})206}207208pub fn evaluate_comp<T>(209	context: Context,210	value: &impl Fn(Context) -> Result<T>,211	specs: &[CompSpec],212) -> Result<Option<Vec<T>>> {213	Ok(match specs.get(0) {214		None => Some(vec![value(context)?]),215		Some(CompSpec::IfSpec(IfSpecData(cond))) => {216			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {217				evaluate_comp(context, value, &specs[1..])?218			} else {219				None220			}221		}222		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {223			Val::Arr(list) => {224				let mut out = Vec::new();225				for item in list.iter() {226					out.push(evaluate_comp(227						context.clone().with_var(var.clone(), item?.clone()),228						value,229						&specs[1..],230					)?);231				}232				Some(out.into_iter().flatten().flatten().collect())233			}234			_ => throw!(InComprehensionCanOnlyIterateOverArray),235		},236	})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	for member in members.iter() {261		match member {262			Member::Field(FieldMember {263				name,264				plus,265				params: None,266				visibility,267				value,268			}) => {269				let name = evaluate_field_name(context.clone(), name)?;270				if name.is_none() {271					continue;272				}273				let name = name.unwrap();274				new_members.insert(275					name.clone(),276					ObjMember {277						add: *plus,278						visibility: *visibility,279						invoke: LazyBinding::Bindable(Rc::new(280							closure!(clone name, clone value, clone context_creator, |this, super_obj| {281								Ok(LazyVal::new_resolved(evaluate_named(282									context_creator.create(this, super_obj)?,283									&value,284									name.clone(),285								)?))286							}),287						)),288						location: value.1.clone(),289					},290				);291			}292			Member::Field(FieldMember {293				name,294				params: Some(params),295				value,296				..297			}) => {298				let name = evaluate_field_name(context.clone(), name)?;299				if name.is_none() {300					continue;301				}302				let name = name.unwrap();303				new_members.insert(304					name.clone(),305					ObjMember {306						add: false,307						visibility: Visibility::Hidden,308						invoke: LazyBinding::Bindable(Rc::new(309							closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {310								// TODO: Assert311								Ok(LazyVal::new_resolved(evaluate_method(312									context_creator.create(this, super_obj)?,313									name.clone(),314									params.clone(),315									value.clone(),316								)))317							}),318						)),319						location: value.1.clone(),320					},321				);322			}323			Member::BindStmt(_) => {}324			Member::AssertStmt(_) => {}325		}326	}327	let this = ObjValue::new(None, Rc::new(new_members));328	future_this.fill(this.clone());329	Ok(this)330}331332pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {333	Ok(match object {334		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,335		ObjBody::ObjComp(obj) => {336			let future_this = FutureWrapper::new();337			let mut new_members = FxHashMap::default();338			for (k, v) in evaluate_comp(339				context.clone(),340				&|ctx| {341					let new_bindings = FutureWrapper::new();342					let context_creator = ContextCreator(context.clone(), new_bindings.clone());343					let mut bindings: FxHashMap<IStr, LazyBinding> = FxHashMap::with_capacity_and_hasher(obj.pre_locals.len() + obj.post_locals.len(), BuildHasherDefault::default());344					for (n, b) in obj345						.pre_locals346						.iter()347						.chain(obj.post_locals.iter())348						.map(|b| evaluate_binding(b, context_creator.clone()))349					{350						bindings.insert(n, b);351					}352					new_bindings.fill(bindings.clone());353					let ctx = ctx.extend_unbound(bindings, None, None, None)?;354					let key = evaluate(ctx.clone(), &obj.key)?;355					let value = LazyBinding::Bindable(Rc::new(356						closure!(clone ctx, clone obj.value, |this, _super_obj| {357							Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))358						}),359					));360361					Ok((key, value))362				},363				&obj.compspecs,364			)?365			.unwrap()366			{367				match k {368					Val::Null => {}369					Val::Str(n) => {370						new_members.insert(371							n,372							ObjMember {373								add: false,374								visibility: Visibility::Normal,375								invoke: v,376								location: obj.value.1.clone(),377							},378						);379					}380					v => throw!(FieldMustBeStringGot(v.value_type())),381				}382			}383384			let this = ObjValue::new(None, Rc::new(new_members));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_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {413	use Expr::*;414	let LocExpr(expr, _loc) = lexpr;415	Ok(match &**expr {416		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),417		_ => evaluate(context, lexpr)?,418	})419}420421pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {422	use Expr::*;423	let LocExpr(expr, loc) = expr;424	Ok(match &**expr {425		Literal(LiteralType::This) => {426			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)427		}428		Literal(LiteralType::Super) => Val::Obj(429			context430				.super_obj()431				.clone()432				.ok_or(NoSuperFound)?433				.with_this(context.this().clone().unwrap()),434		),435		Literal(LiteralType::Dollar) => {436			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)437		}438		Literal(LiteralType::True) => Val::Bool(true),439		Literal(LiteralType::False) => Val::Bool(false),440		Literal(LiteralType::Null) => Val::Null,441		Parened(e) => evaluate(context, e)?,442		Str(v) => Val::Str(v.clone()),443		Num(v) => Val::new_checked_num(*v)?,444		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,445		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,446		Var(name) => push(447			loc.as_ref(),448			|| format!("variable <{}>", name),449			|| context.binding(name.clone())?.evaluate(),450		)?,451		Index(value, index) => {452			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {453				(Val::Obj(v), Val::Str(s)) => {454					let sn = s.clone();455					push(456						loc.as_ref(),457						|| format!("field <{}> access", sn),458						|| {459							if let Some(v) = v.get(s.clone())? {460								Ok(v)461							} else if v.get("__intrinsic_namespace__".into())?.is_some() {462								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))463							} else {464								throw!(NoSuchField(s))465							}466						},467					)?468				}469				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(470					ValType::Obj,471					ValType::Str,472					n.value_type(),473				)),474475				(Val::Arr(v), Val::Num(n)) => {476					if n.fract() > f64::EPSILON {477						throw!(FractionalIndex)478					}479					v.get(n as usize)?480						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?481				}482				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),483				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(484					ValType::Arr,485					ValType::Num,486					n.value_type(),487				)),488489				(Val::Str(s), Val::Num(n)) => Val::Str(490					s.chars()491						.skip(n as usize)492						.take(1)493						.collect::<String>()494						.into(),495				),496				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(497					ValType::Str,498					ValType::Num,499					n.value_type(),500				)),501502				(v, _) => throw!(CantIndexInto(v.value_type())),503			}504		}505		LocalExpr(bindings, returned) => {506			let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(507				bindings.len(),508				BuildHasherDefault::<FxHasher>::default(),509			);510			let future_context = Context::new_future();511			for b in bindings {512				new_bindings.insert(513					b.name.clone(),514					evaluate_binding_in_future(b, future_context.clone()),515				);516			}517			let context = context518				.extend_bound(new_bindings)519				.into_future(future_context);520			evaluate(context, &returned.clone())?521		}522		Arr(items) => {523			let mut out = Vec::with_capacity(items.len());524			for item in items {525				out.push(LazyVal::new(Box::new(526					closure!(clone context, clone item, || {527						evaluate(context.clone(), &item)528					}),529				)));530			}531			Val::Arr(out.into())532		}533		ArrComp(expr, comp_specs) => Val::Arr(534			// First comp_spec should be for_spec, so no "None" possible here535			evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?536				.unwrap()537				.into(),538		),539		Obj(body) => Val::Obj(evaluate_object(context, body)?),540		ObjExtend(s, t) => evaluate_add_op(541			&evaluate(context.clone(), s)?,542			&Val::Obj(evaluate_object(context, t)?),543		)?,544		Apply(value, args, tailstrict) => {545			evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?546		}547		Function(params, body) => {548			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())549		}550		Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),551		AssertExpr(AssertStmt(value, msg), returned) => {552			let assertion_result = push(553				value.1.as_ref(),554				|| "assertion condition".to_owned(),555				|| {556					evaluate(context.clone(), value)?557						.try_cast_bool("assertion condition should be of type `boolean`")558				},559			)?;560			if assertion_result {561				evaluate(context, returned)?562			} else {563				push(564					value.1.as_ref(),565					|| "assertion failure".to_owned(),566					|| {567						if let Some(msg) = msg {568							throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));569						} else {570							throw!(AssertionFailed(Val::Null.to_string()?));571						}572					},573				)?574			}575		}576		ErrorStmt(e) => push(577			loc.as_ref(),578			|| "error statement".to_owned(),579			|| {580				throw!(RuntimeError(581					evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,582				))583			},584		)?,585		IfElse {586			cond,587			cond_then,588			cond_else,589		} => {590			if push(591				loc.as_ref(),592				|| "if condition".to_owned(),593				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),594			)? {595				evaluate(context, cond_then)?596			} else {597				match cond_else {598					Some(v) => evaluate(context, v)?,599					None => Val::Null,600				}601			}602		}603		Import(path) => {604			let mut tmp = loc605				.clone()606				.expect("imports cannot be used without loc_data")607				.0;608			let import_location = Rc::make_mut(&mut tmp);609			import_location.pop();610			push(611				loc.as_ref(),612				|| format!("import {:?}", path),613				|| with_state(|s| s.import_file(import_location, path)),614			)?615		}616		ImportStr(path) => {617			let mut tmp = loc618				.clone()619				.expect("imports cannot be used without loc_data")620				.0;621			let import_location = Rc::make_mut(&mut tmp);622			import_location.pop();623			Val::Str(with_state(|s| s.import_file_str(import_location, path))?)624		}625	})626}