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

1use crate::{2	error::Error::*, lazy_val, push, throw, with_state, Context, ContextCreator, FuncDesc, FuncVal,3	FutureWrapper, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,4	equals,5};6use closure::closure;7use jrsonnet_interner::IStr;8use jrsonnet_parser::{9	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,10	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,11	Visibility,12};13use jrsonnet_types::ValType;14use rustc_hash::{FxHashMap, FxHasher};15use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};1617pub fn evaluate_binding_in_future(18	b: &BindSpec,19	context_creator: FutureWrapper<Context>,20) -> LazyVal {21	let b = b.clone();22	if let Some(params) = &b.params {23		let params = params.clone();24		LazyVal::new(Box::new(move || {25			Ok(evaluate_method(26				context_creator.unwrap(),27				b.name.clone(),28				params.clone(),29				b.value.clone(),30			))31		}))32	} else {33		LazyVal::new(Box::new(move || {34			evaluate_named(context_creator.unwrap(), &b.value, b.name.clone())35		}))36	}37}3839pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {40	let b = b.clone();41	if let Some(params) = &b.params {42		let params = params.clone();43		(44			b.name.clone(),45			LazyBinding::Bindable(Rc::new(move |this, super_obj| {46				Ok(lazy_val!(47					closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(48						context_creator.create(this.clone(), super_obj.clone())?,49						b.name.clone(),50						params.clone(),51						b.value.clone(),52					)))53				))54			})),55		)56	} else {57		(58			b.name.clone(),59			LazyBinding::Bindable(Rc::new(move |this, super_obj| {60				Ok(lazy_val!(closure!(clone context_creator, clone b, ||61					evaluate_named(62						context_creator.create(this.clone(), super_obj.clone())?,63						&b.value,64						b.name.clone()65					)66				)))67			})),68		)69	}70}7172pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {73	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {74		name,75		ctx,76		params,77		body,78	})))79}8081pub fn evaluate_field_name(82	context: Context,83	field_name: &jrsonnet_parser::FieldName,84) -> Result<Option<IStr>> {85	Ok(match field_name {86		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),87		jrsonnet_parser::FieldName::Dyn(expr) => {88			let value = evaluate(context, expr)?;89			if matches!(value, Val::Null) {90				None91			} else {92				Some(value.try_cast_str("dynamic field name")?)93			}94		}95	})96}9798pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {99	Ok(match (op, b) {100		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),101		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),102		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),103		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),104	})105}106107pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {108	Ok(match (a, b) {109		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),110111		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)112		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),113		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),114115		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().to_string()?).into()),116		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),117118		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.extend_from(v1.clone())),119		(Val::Arr(a), Val::Arr(b)) => {120			let mut out = Vec::with_capacity(a.len() + b.len());121			out.extend(a.iter_lazy());122			out.extend(b.iter_lazy());123			Val::Arr(out.into())124		}125		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,126		_ => throw!(BinaryOperatorDoesNotOperateOnValues(127			BinaryOpType::Add,128			a.value_type(),129			b.value_type(),130		)),131	})132}133134pub fn evaluate_binary_op_special(135	context: Context,136	a: &LocExpr,137	op: BinaryOpType,138	b: &LocExpr,139) -> Result<Val> {140	Ok(match (evaluate(context.clone(), a)?, op, b) {141		(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),142		(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),143		(a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,144	})145}146147pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {148	Ok(match (a, op, b) {149		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,150151		(a, BinaryOpType::Eq, b) => Val::Bool(equals(&a, &b)?),152		(a, BinaryOpType::Neq, b) => Val::Bool(!equals(&a, &b)?),153154		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),155156		// Bool X Bool157		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),158		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),159160		// Str X Str161		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),162		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),163		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),164		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),165166		// Num X Num167		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,168		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {169			if *v2 <= f64::EPSILON {170				throw!(DivisionByZero)171			}172			Val::new_checked_num(v1 / v2)?173		}174175		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,176177		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),178		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),179		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),180		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),181182		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {183			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)184		}185		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {186			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)187		}188		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {189			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)190		}191		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {192			if *v2 < 0.0 {193				throw!(RuntimeError("shift by negative exponent".into()))194			}195			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)196		}197		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {198			if *v2 < 0.0 {199				throw!(RuntimeError("shift by negative exponent".into()))200			}201			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)202		}203204		_ => throw!(BinaryOperatorDoesNotOperateOnValues(205			op,206			a.value_type(),207			b.value_type(),208		)),209	})210}211212pub fn evaluate_comp<T>(213	context: Context,214	value: &impl Fn(Context) -> Result<T>,215	specs: &[CompSpec],216) -> Result<Option<Vec<T>>> {217	Ok(match specs.get(0) {218		None => Some(vec![value(context)?]),219		Some(CompSpec::IfSpec(IfSpecData(cond))) => {220			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {221				evaluate_comp(context, value, &specs[1..])?222			} else {223				None224			}225		}226		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {227			Val::Arr(list) => {228				let mut out = Vec::new();229				for item in list.iter() {230					out.push(evaluate_comp(231						context.clone().with_var(var.clone(), item?.clone()),232						value,233						&specs[1..],234					)?);235				}236				Some(out.into_iter().flatten().flatten().collect())237			}238			_ => throw!(InComprehensionCanOnlyIterateOverArray),239		},240	})241}242243pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {244	let new_bindings = FutureWrapper::new();245	let future_this = FutureWrapper::new();246	let context_creator = ContextCreator(context.clone(), new_bindings.clone());247	{248		let mut bindings: FxHashMap<IStr, LazyBinding> =249			FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());250		for (n, b) in members251			.iter()252			.filter_map(|m| match m {253				Member::BindStmt(b) => Some(b.clone()),254				_ => None,255			})256			.map(|b| evaluate_binding(&b, context_creator.clone()))257		{258			bindings.insert(n, b);259		}260		new_bindings.fill(bindings);261	}262263	let mut new_members = FxHashMap::default();264	let mut assertions = Vec::new();265	for member in members.iter() {266		match member {267			Member::Field(FieldMember {268				name,269				plus,270				params: None,271				visibility,272				value,273			}) => {274				let name = evaluate_field_name(context.clone(), name)?;275				if name.is_none() {276					continue;277				}278				let name = name.unwrap();279				new_members.insert(280					name.clone(),281					ObjMember {282						add: *plus,283						visibility: *visibility,284						invoke: LazyBinding::Bindable(Rc::new(285							closure!(clone name, clone value, clone context_creator, |this, super_obj| {286								Ok(LazyVal::new_resolved(evaluate_named(287									context_creator.create(this, super_obj)?,288									&value,289									name.clone(),290								)?))291							}),292						)),293						location: value.1.clone(),294					},295				);296			}297			Member::Field(FieldMember {298				name,299				params: Some(params),300				value,301				..302			}) => {303				let name = evaluate_field_name(context.clone(), name)?;304				if name.is_none() {305					continue;306				}307				let name = name.unwrap();308				new_members.insert(309					name.clone(),310					ObjMember {311						add: false,312						visibility: Visibility::Hidden,313						invoke: LazyBinding::Bindable(Rc::new(314							closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {315								// TODO: Assert316								Ok(LazyVal::new_resolved(evaluate_method(317									context_creator.create(this, super_obj)?,318									name.clone(),319									params.clone(),320									value.clone(),321								)))322							}),323						)),324						location: value.1.clone(),325					},326				);327			}328			Member::BindStmt(_) => {}329			Member::AssertStmt(stmt) => {330				assertions.push(stmt.clone());331			}332		}333	}334	let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(assertions));335	future_this.fill(this.clone());336	Ok(this)337}338339pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {340	Ok(match object {341		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,342		ObjBody::ObjComp(obj) => {343			let future_this = FutureWrapper::new();344			let mut new_members = FxHashMap::default();345			for (k, v) in evaluate_comp(346				context.clone(),347				&|ctx| {348					let new_bindings = FutureWrapper::new();349					let context_creator = ContextCreator(context.clone(), new_bindings.clone());350					let mut bindings: FxHashMap<IStr, LazyBinding> = FxHashMap::with_capacity_and_hasher(obj.pre_locals.len() + obj.post_locals.len(), BuildHasherDefault::default());351					for (n, b) in obj352						.pre_locals353						.iter()354						.chain(obj.post_locals.iter())355						.map(|b| evaluate_binding(b, context_creator.clone()))356					{357						bindings.insert(n, b);358					}359					new_bindings.fill(bindings.clone());360					let ctx = ctx.extend_unbound(bindings, None, None, None)?;361					let key = evaluate(ctx.clone(), &obj.key)?;362					let value = LazyBinding::Bindable(Rc::new(363						closure!(clone ctx, clone obj.value, |this, _super_obj| {364							Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))365						}),366					));367368					Ok((key, value))369				},370				&obj.compspecs,371			)?372			.unwrap()373			{374				match k {375					Val::Null => {}376					Val::Str(n) => {377						new_members.insert(378							n,379							ObjMember {380								add: false,381								visibility: Visibility::Normal,382								invoke: v,383								location: obj.value.1.clone(),384							},385						);386					}387					v => throw!(FieldMustBeStringGot(v.value_type())),388				}389			}390391			let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(Vec::new()));392			future_this.fill(this.clone());393			this394		}395	})396}397398pub fn evaluate_apply(399	context: Context,400	value: &LocExpr,401	args: &ArgsDesc,402	loc: Option<&ExprLocation>,403	tailstrict: bool,404) -> Result<Val> {405	let value = evaluate(context.clone(), value)?;406	Ok(match value {407		Val::Func(f) => {408			let body = || f.evaluate(context, loc, args, tailstrict);409			if tailstrict {410				body()?411			} else {412				push(loc, || format!("function <{}> call", f.name()), body)?413			}414		}415		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),416	})417}418419pub fn evaluate_assert(420	context: Context,421	assertion: &AssertStmt,422) -> Result<()> {423	let value = &assertion.0;424	let msg = &assertion.1;425	let assertion_result = push(426		value.1.as_ref(),427		|| "assertion condition".to_owned(),428		|| {429			evaluate(context.clone(), value)?430				.try_cast_bool("assertion condition should be of type `boolean`")431		},432	)?;433	if !assertion_result {434		push(435			value.1.as_ref(),436			|| "assertion failure".to_owned(),437			|| {438				if let Some(msg) = msg {439					throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));440				} else {441					throw!(AssertionFailed(Val::Null.to_string()?));442				}443			},444		)?445	}446	Ok(())447}448449pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {450	use Expr::*;451	let LocExpr(expr, _loc) = lexpr;452	Ok(match &**expr {453		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),454		_ => evaluate(context, lexpr)?,455	})456}457458pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {459	use Expr::*;460	let LocExpr(expr, loc) = expr;461	Ok(match &**expr {462		Literal(LiteralType::This) => {463			Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)464		}465		Literal(LiteralType::Super) => Val::Obj(466			context467				.super_obj()468				.clone()469				.ok_or(NoSuperFound)?470				.with_this(context.this().clone().unwrap()),471		),472		Literal(LiteralType::Dollar) => {473			Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)474		}475		Literal(LiteralType::True) => Val::Bool(true),476		Literal(LiteralType::False) => Val::Bool(false),477		Literal(LiteralType::Null) => Val::Null,478		Parened(e) => evaluate(context, e)?,479		Str(v) => Val::Str(v.clone()),480		Num(v) => Val::new_checked_num(*v)?,481		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,482		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,483		Var(name) => push(484			loc.as_ref(),485			|| format!("variable <{}>", name),486			|| context.binding(name.clone())?.evaluate(),487		)?,488		Index(value, index) => {489			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {490				(Val::Obj(v), Val::Str(s)) => {491					let sn = s.clone();492					push(493						loc.as_ref(),494						|| format!("field <{}> access", sn),495						|| {496							if let Some(v) = v.get(s.clone())? {497								Ok(v)498							} else if v.get("__intrinsic_namespace__".into())?.is_some() {499								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))500							} else {501								throw!(NoSuchField(s))502							}503						},504					)?505				}506				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(507					ValType::Obj,508					ValType::Str,509					n.value_type(),510				)),511512				(Val::Arr(v), Val::Num(n)) => {513					if n.fract() > f64::EPSILON {514						throw!(FractionalIndex)515					}516					v.get(n as usize)?517						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?518				}519				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),520				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(521					ValType::Arr,522					ValType::Num,523					n.value_type(),524				)),525526				(Val::Str(s), Val::Num(n)) => Val::Str(527					s.chars()528						.skip(n as usize)529						.take(1)530						.collect::<String>()531						.into(),532				),533				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(534					ValType::Str,535					ValType::Num,536					n.value_type(),537				)),538539				(v, _) => throw!(CantIndexInto(v.value_type())),540			}541		}542		LocalExpr(bindings, returned) => {543			let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(544				bindings.len(),545				BuildHasherDefault::<FxHasher>::default(),546			);547			let future_context = Context::new_future();548			for b in bindings {549				new_bindings.insert(550					b.name.clone(),551					evaluate_binding_in_future(b, future_context.clone()),552				);553			}554			let context = context555				.extend_bound(new_bindings)556				.into_future(future_context);557			evaluate(context, &returned.clone())?558		}559		Arr(items) => {560			let mut out = Vec::with_capacity(items.len());561			for item in items {562				out.push(LazyVal::new(Box::new(563					closure!(clone context, clone item, || {564						evaluate(context.clone(), &item)565					}),566				)));567			}568			Val::Arr(out.into())569		}570		ArrComp(expr, comp_specs) => Val::Arr(571			// First comp_spec should be for_spec, so no "None" possible here572			evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?573				.unwrap()574				.into(),575		),576		Obj(body) => Val::Obj(evaluate_object(context, body)?),577		ObjExtend(s, t) => evaluate_add_op(578			&evaluate(context.clone(), s)?,579			&Val::Obj(evaluate_object(context, t)?),580		)?,581		Apply(value, args, tailstrict) => {582			evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?583		}584		Function(params, body) => {585			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())586		}587		Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),588		AssertExpr(assert, returned) => {589			evaluate_assert(context.clone(), &assert)?;590			evaluate(context, returned)?591		}592		ErrorStmt(e) => push(593			loc.as_ref(),594			|| "error statement".to_owned(),595			|| {596				throw!(RuntimeError(597					evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,598				))599			},600		)?,601		IfElse {602			cond,603			cond_then,604			cond_else,605		} => {606			if push(607				loc.as_ref(),608				|| "if condition".to_owned(),609				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),610			)? {611				evaluate(context, cond_then)?612			} else {613				match cond_else {614					Some(v) => evaluate(context, v)?,615					None => Val::Null,616				}617			}618		}619		Import(path) => {620			let mut tmp = loc621				.clone()622				.expect("imports cannot be used without loc_data")623				.0;624			let import_location = Rc::make_mut(&mut tmp);625			import_location.pop();626			push(627				loc.as_ref(),628				|| format!("import {:?}", path),629				|| with_state(|s| s.import_file(import_location, path)),630			)?631		}632		ImportStr(path) => {633			let mut tmp = loc634				.clone()635				.expect("imports cannot be used without loc_data")636				.0;637			let import_location = Rc::make_mut(&mut tmp);638			import_location.pop();639			Val::Str(with_state(|s| s.import_file_str(import_location, path))?)640		}641	})642}