git.delta.rocks / jrsonnet / refs/commits / 0ba2642a3a69

1use crate::{2	context_creator, create_error, escape_string_json, future_wrapper, lazy_val, manifest_json_ex,3	parse_args, push, with_state, Context, ContextCreator, Error, FuncDesc, LazyBinding, LazyVal,4	ObjMember, ObjValue, Result, Val, ValType,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(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {18	let b = b.clone();19	if let Some(params) = &b.params {20		let params = params.clone();21		(22			b.name.clone(),23			LazyBinding::Bindable(Rc::new(move |this, super_obj| {24				Ok(lazy_val!(25					closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(26						context_creator.0(this.clone(), super_obj.clone())?,27						params.clone(),28						b.value.clone(),29					)))30				))31			})),32		)33	} else {34		(35			b.name.clone(),36			LazyBinding::Bindable(Rc::new(move |this, super_obj| {37				Ok(lazy_val!(closure!(clone context_creator, clone b, ||38					push(&b.value.1, "thunk", ||{39						evaluate(40							context_creator.0(this.clone(), super_obj.clone())?,41							&b.value42						)43					})44				)))45			})),46		)47	}48}4950pub fn evaluate_method(ctx: Context, params: ParamsDesc, body: LocExpr) -> Val {51	Val::Func(FuncDesc { ctx, params, body })52}5354pub fn evaluate_field_name(55	context: Context,56	field_name: &jsonnet_parser::FieldName,57) -> Result<Option<Rc<str>>> {58	Ok(match field_name {59		jsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),60		jsonnet_parser::FieldName::Dyn(expr) => {61			let lazy = evaluate(context, expr)?;62			let value = lazy.unwrap_if_lazy()?;63			if matches!(value, Val::Null) {64				None65			} else {66				Some(value.try_cast_str("dynamic field name")?)67			}68		}69	})70}7172pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {73	Ok(match (op, b) {74		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,75		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),76		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),77		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),78		(op, o) => panic!("unary op not implemented: {:?} {:?}", op, o),79	})80}8182pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {83	Ok(match (a, b) {84		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),8586		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)87		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),88		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),8990		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),91		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),9293		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),94		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),95		(Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),96		_ => panic!("can't add: {:?} and {:?}", a, b),97	})98}99100pub fn evaluate_binary_op_special(101	context: Context,102	a: &LocExpr,103	op: BinaryOpType,104	b: &LocExpr,105) -> Result<Val> {106	Ok(107		match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {108			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),109			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),110			(a, op, eb) => {111				evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?112			}113		},114	)115}116117pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {118	Ok(match (a, op, b) {119		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,120121		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),122123		// Bool X Bool124		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),125		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),126127		// Str X Str128		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),129		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),130		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),131		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),132133		// Num X Num134		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Num(v1 * v2),135		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {136			if *v2 <= f64::EPSILON {137				create_error(crate::Error::DivisionByZero)?138			}139			Val::Num(v1 / v2)140		}141142		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::Num(v1 - v2),143144		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),145		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),146		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),147		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),148149		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {150			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)151		}152		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {153			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)154		}155		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {156			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)157		}158		(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		_ => panic!("no rules for binary operation: {:?} {:?} {:?}", a, op, b),166	})167}168169future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);170future_wrapper!(ObjValue, FutureObjValue);171172pub fn evaluate_comp<T>(173	context: Context,174	value: &impl Fn(Context) -> Result<T>,175	specs: &[CompSpec],176) -> Result<Option<Vec<T>>> {177	Ok(match specs.get(0) {178		None => Some(vec![value(context)?]),179		Some(CompSpec::IfSpec(IfSpecData(cond))) => {180			if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {181				evaluate_comp(context, value, &specs[1..])?182			} else {183				None184			}185		}186		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {187			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {188				Val::Arr(list) => {189					let mut out = Vec::new();190					for item in list.iter() {191						let item = item.unwrap_if_lazy()?;192						out.push(evaluate_comp(193							context.with_var(var.clone(), item.clone())?,194							value,195							&specs[1..],196						)?);197					}198					Some(out.into_iter().flatten().flatten().collect())199				}200				_ => panic!("for expression evaluated to non-iterable value"),201			}202		}203	})204}205206pub fn evaluate_member_list_object(context: Context, members: &Vec<Member>) -> Result<ObjValue> {207	let new_bindings = FutureNewBindings::new();208	let future_this = FutureObjValue::new();209	let context_creator = context_creator!(210		closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {211			Ok(context.extend_unbound(212				new_bindings.clone().unwrap(),213				context.dollar().clone().or_else(||this.clone()),214				Some(this.unwrap()),215				super_obj216			)?)217		})218	);219	{220		let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();221		for (n, b) in members222			.iter()223			.filter_map(|m| match m {224				Member::BindStmt(b) => Some(b.clone()),225				_ => None,226			})227			.map(|b| evaluate_binding(&b, context_creator.clone()))228		{229			bindings.insert(n, b);230		}231		new_bindings.fill(bindings);232	}233234	let mut new_members = BTreeMap::new();235	for member in members.iter() {236		match member {237			Member::Field(FieldMember {238				name,239				plus,240				params: None,241				visibility,242				value,243			}) => {244				let name = evaluate_field_name(context.clone(), &name)?;245				if name.is_none() {246					continue;247				}248				let name = name.unwrap();249				new_members.insert(250					name.clone(),251					ObjMember {252						add: *plus,253						visibility: *visibility,254						invoke: LazyBinding::Bindable(Rc::new(255							closure!(clone name, clone value, clone context_creator, |this, super_obj| {256								Ok(LazyVal::new_resolved(push(&value.1, "object field", ||{257									let context = context_creator.0(this, super_obj)?;258									evaluate(259										context,260										&value,261									)262								})?))263							}),264						)),265					},266				);267			}268			Member::Field(FieldMember {269				name,270				params: Some(params),271				value,272				..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,281					ObjMember {282						add: false,283						visibility: Visibility::Hidden,284						invoke: LazyBinding::Bindable(Rc::new(285							closure!(clone value, clone context_creator, clone params, |this, super_obj| {286								// TODO: Assert287								Ok(LazyVal::new_resolved(evaluate_method(288									context_creator.0(this, super_obj)?,289									params.clone(),290									value.clone(),291								)))292							}),293						)),294					},295				);296			}297			Member::BindStmt(_) => {}298			Member::AssertStmt(_) => {}299		}300	}301	Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))302}303304pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {305	Ok(match object {306		ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,307		ObjBody::ObjComp(obj) => {308			let future_this = FutureObjValue::new();309			let mut new_members = BTreeMap::new();310			for (k, v) in evaluate_comp(311				context.clone(),312				&|ctx| {313					let new_bindings = FutureNewBindings::new();314					let context_creator = context_creator!(315						closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {316							Ok(context.extend_unbound(317								new_bindings.clone().unwrap(),318								context.dollar().clone().or_else(||this.clone()),319								None,320								super_obj321							)?)322						})323					);324					let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();325					for (n, b) in obj326						.pre_locals327						.iter()328						.chain(obj.post_locals.iter())329						.map(|b| evaluate_binding(b, context_creator.clone()))330					{331						bindings.insert(n, b);332					}333					let bindings = new_bindings.fill(bindings);334					let ctx = ctx.extend_unbound(bindings, None, None, None)?;335					let key = evaluate(ctx.clone(), &obj.key)?;336					let value = LazyBinding::Bindable(Rc::new(337						closure!(clone ctx, clone obj.value, |this, _super_obj| {338							Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))339						}),340					));341342					Ok((key, value))343				},344				&obj.compspecs,345			)?346			.unwrap()347			{348				match k {349					Val::Null => {}350					Val::Str(n) => {351						new_members.insert(352							n,353							ObjMember {354								add: false,355								visibility: Visibility::Normal,356								invoke: v,357							},358						);359					}360					v => create_error(Error::FieldMustBeStringGot(v.value_type()?))?,361				}362			}363364			future_this.fill(ObjValue::new(None, Rc::new(new_members)))365		}366	})367}368369pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {370	use Expr::*;371	let LocExpr(expr, loc) = expr;372	Ok(match &**expr {373		Literal(LiteralType::This) => Val::Obj(374			context375				.this()376				.clone()377				.unwrap_or_else(|| panic!("this not found")),378		),379		Literal(LiteralType::Dollar) => Val::Obj(380			context381				.dollar()382				.clone()383				.unwrap_or_else(|| panic!("dollar not found")),384		),385		Literal(LiteralType::True) => Val::Bool(true),386		Literal(LiteralType::False) => Val::Bool(false),387		Literal(LiteralType::Null) => Val::Null,388		Parened(e) => evaluate(context, e)?,389		Str(v) => Val::Str(v.clone()),390		Num(v) => Val::Num(*v),391		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,392		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,393		Var(name) => push(loc, "var", || {394			Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?)395		})?,396		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {397			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;398			context399				.super_obj()400				.clone()401				.expect("no super found")402				.get_raw(&name, &context.this().clone().expect("no this found"))?403				.expect("value not found")404		}405		Index(value, index) => {406			match (407				evaluate(context.clone(), value)?.unwrap_if_lazy()?,408				evaluate(context, index)?,409			) {410				(Val::Obj(v), Val::Str(s)) => {411					if let Some(v) = v.get(s.clone())? {412						v.unwrap_if_lazy()?413					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {414						Val::Intristic(n, s)415					} else {416						create_error(crate::Error::NoSuchField(s))?417					}418				}419				(Val::Obj(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(420					ValType::Obj,421					ValType::Str,422					n.value_type()?,423				))?,424425				(Val::Arr(v), Val::Num(n)) => {426					if n.fract() > f64::EPSILON {427						create_error(crate::Error::FractionalIndex)?428					}429					v.get(n as usize)430						.unwrap_or_else(|| panic!("out of bounds"))431						.clone()432						.unwrap_if_lazy()?433				}434				(Val::Arr(_), Val::Str(n)) => {435					create_error(crate::Error::AttemptedIndexAnArrayWithString(n))?436				}437				(Val::Arr(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(438					ValType::Arr,439					ValType::Num,440					n.value_type()?,441				))?,442443				(Val::Str(s), Val::Num(n)) => Val::Str(444					s.chars()445						.skip(n as usize)446						.take(1)447						.collect::<String>()448						.into(),449				),450				(Val::Str(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(451					ValType::Str,452					ValType::Num,453					n.value_type()?,454				))?,455456				(v, _) => create_error(crate::Error::CantIndexInto(v.value_type()?))?,457			}458		}459		LocalExpr(bindings, returned) => {460			let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();461			let future_context = Context::new_future();462463			let context_creator = context_creator!(464				closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))465			);466467			for (k, v) in bindings468				.iter()469				.map(|b| evaluate_binding(b, context_creator.clone()))470			{471				new_bindings.insert(k, v);472			}473474			let context = context475				.extend_unbound(new_bindings, None, None, None)?476				.into_future(future_context);477			evaluate(context, &returned.clone())?478		}479		Arr(items) => {480			let mut out = Vec::with_capacity(items.len());481			for item in items {482				out.push(Val::Lazy(lazy_val!(483					closure!(clone context, clone item, || {484						evaluate(context.clone(), &item)485					})486				)));487			}488			Val::Arr(Rc::new(out))489		}490		ArrComp(expr, compspecs) => Val::Arr(491			// First compspec should be forspec, so no "None" possible here492			Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),493		),494		Obj(body) => Val::Obj(evaluate_object(context, body)?),495		ObjExtend(s, t) => evaluate_add_op(496			&evaluate(context.clone(), s)?,497			&Val::Obj(evaluate_object(context, t)?),498		)?,499		Apply(value, args, tailstrict) => {500			let lazy = evaluate(context.clone(), value)?;501			let value = lazy.unwrap_if_lazy()?;502			match value {503				Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {504					// arr/string/function505					("std", "length") => parse_args!(context, "std.length", args, 1, [506						0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];507					], {508						match x {509							Val::Str(n) => Val::Num(n.chars().count() as f64),510							Val::Arr(i) => Val::Num(i.len() as f64),511							Val::Obj(o) => Val::Num(512								o.fields_visibility()513									.into_iter()514									.filter(|(_k, v)| *v)515									.count() as f64,516							),517							_ => unreachable!(),518						}519					}),520					// any521					("std", "type") => parse_args!(context, "std.type", args, 1, [522						0, x, vec![];523					], {524						Val::Str(x.value_type()?.name().into())525					}),526					// length, idx=>any527					("std", "makeArray") => parse_args!(context, "std.makeArray", args, 2, [528						0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];529						1, func: [Val::Func]!!Val::Func, vec![ValType::Func];530					], {531						assert!(sz >= 0.0);532						let mut out = Vec::with_capacity(sz as usize);533						for i in 0..sz as usize {534							out.push(func.evaluate_values(535								Context::new(),536								&[Val::Num(i as f64)]537							)?)538						}539						Val::Arr(Rc::new(out))540					}),541					// string542					("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [543						0, str: [Val::Str]!!Val::Str, vec![ValType::Str];544					], {545						assert!(546							str.chars().count() == 1,547							"std.codepoint should receive single char string"548						);549						Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)550					}),551					// object, includeHidden552					("std", "objectFieldsEx") => {553						parse_args!(context, "std.objectFieldsEx",args, 2, [554							0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];555							1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];556						], {557							Val::Arr(Rc::new(558								obj.fields_visibility()559									.into_iter()560									.filter(|(_k, v)| *v || inc_hidden)561									.map(|(k, _v)| Val::Str(k))562									.collect(),563							))564						})565					}566					// object, field, includeHidden567					("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [568						0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];569						1, f: [Val::Str]!!Val::Str, vec![ValType::Str];570						2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];571					], {572						Val::Bool(573							obj.fields_visibility()574								.into_iter()575								.filter(|(_k, v)| *v || inc_hidden)576								.any(|(k, _v)| *k == *f),577						)578					}),579					("std", "primitiveEquals") => {580						parse_args!(context, "std.primitiveEquals", args, 2, [581							0, a, vec![];582							1, b, vec![];583						], {584							Val::Bool(a == b)585						})586					}587					("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [588						0, a: [Val::Num]!!Val::Num, vec![ValType::Num];589						1, b: [Val::Num]!!Val::Num, vec![ValType::Num];590					], {591						Val::Num(a % b)592					}),593					("std", "floor") => parse_args!(context, "std.floor", args, 1, [594						0, x: [Val::Num]!!Val::Num, vec![ValType::Num];595					], {596						Val::Num(x.floor())597					}),598					("std", "trace") => parse_args!(context, "std.trace", args, 2, [599						0, str: [Val::Str]!!Val::Str, vec![ValType::Str];600						1, rest, vec![];601					], {602						// TODO: Line numbers as in original jsonnet603						println!("TRACE: {}", str);604						rest605					}),606					("std", "pow") => parse_args!(context, "std.modulo", args, 2, [607						0, x: [Val::Num]!!Val::Num, vec![ValType::Num];608						1, n: [Val::Num]!!Val::Num, vec![ValType::Num];609					], {610						Val::Num(x.powf(n))611					}),612					("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [613						0, x: [Val::Str]!!Val::Str, vec![ValType::Str];614					], {615						with_state(|s| s.0.ext_vars.borrow().get(&x).cloned()).ok_or_else(616							|| {617								create_error::<()>(crate::Error::UndefinedExternalVariable(x))618									.err()619									.unwrap()620							},621						)?622					}),623					("std", "filter") => parse_args!(context, "std.filter", args, 2, [624						0, func: [Val::Func]!!Val::Func, vec![ValType::Func];625						1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];626					], {627						Val::Arr(Rc::new(628							arr.iter()629								.cloned()630								.filter(|e| {631									func632										.evaluate_values(context.clone(), &[e.clone()])633										.unwrap()634										.try_cast_bool("filter predicate")635										.unwrap()636								})637								.collect(),638						))639					}),640					("std", "char") => parse_args!(context, "std.char", args, 1, [641						0, n: [Val::Num]!!Val::Num, vec![ValType::Num];642					], {643						let mut out = String::new();644						out.push(std::char::from_u32(n as u32).unwrap());645						Val::Str(out.into())646					}),647					("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [648						0, str: [Val::Str]!!Val::Str, vec![ValType::Str];649					], {650						Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))651					}),652					("std", "md5") => parse_args!(context, "std.md5", args, 1, [653						0, str: [Val::Str]!!Val::Str, vec![ValType::Str];654					], {655						Val::Str(format!("{:x}", md5::compute(str.as_bytes())).into())656					}),657					// faster658					("std", "join") => parse_args!(context, "std.join", args, 2, [659						0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];660						1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];661					], {662						match sep {663							Val::Arr(joiner_items) => {664								let mut out = Vec::new();665666								let mut first = true;667								for item in arr.iter().cloned() {668									if let Val::Arr(items) = item.unwrap_if_lazy()? {669										if !first {670											out.reserve(joiner_items.len());671											out.extend(joiner_items.iter().cloned());672										}673										first = false;674										out.reserve(items.len());675										out.extend(items.iter().cloned());676									} else {677										panic!("all array items should be arrays")678									}679								}680681								Val::Arr(Rc::new(out))682							},683							Val::Str(sep) => {684								let mut out = String::new();685686								let mut first = true;687								for item in arr.iter().cloned() {688									if let Val::Str(item) = item.unwrap_if_lazy()? {689										if !first {690											out += &sep;691										}692										first = false;693										out += &item;694									} else {695										panic!("all array items should be strings")696									}697								}698699								Val::Str(out.into())700							},701							_ => unreachable!()702						}703					}),704					// Faster705					("std", "escapeStringJson") => {706						parse_args!(context, "std.escapeStringJson", args, 1, [707							0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];708						], {709							Val::Str(escape_string_json(&str_).into())710						})711					}712					// Faster713					("std", "manifestJsonEx") => {714						parse_args!(context, "std.manifestJsonEx", args, 2, [715							0, value, vec![];716							1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];717						], {718							Val::Str(manifest_json_ex(&value, &indent)?.into())719						})720					}721					(ns, name) => create_error(crate::error::Error::IntristicNotFound(722						ns.into(),723						name.into(),724					))?,725				},726				Val::Func(f) => {727					let body = || f.evaluate(context, args, *tailstrict);728					if *tailstrict {729						body()?730					} else {731						push(loc, "function call", body)?732					}733				}734				v => create_error(crate::error::Error::OnlyFunctionsCanBeCalledGot(735					v.value_type()?,736				))?,737			}738		}739		Function(params, body) => evaluate_method(context, params.clone(), body.clone()),740		AssertExpr(AssertStmt(value, msg), returned) => {741			let assertion_result = push(&value.1, "assertion condition", || {742				evaluate(context.clone(), &value)?743					.try_cast_bool("assertion condition should be boolean")744			})?;745			if assertion_result {746				evaluate(context, returned)?747			} else if let Some(msg) = msg {748				panic!(749					"assertion failed ({:?}): {}",750					value,751					evaluate(context, msg)?.try_cast_str("assertion message should be string")?752				);753			} else {754				panic!("assertion failed ({:?}): no message", value);755			}756		}757		Error(e) => create_error(crate::Error::RuntimeError(758			evaluate(context, e)?.try_cast_str("error text should be string")?,759		))?,760		IfElse {761			cond,762			cond_then,763			cond_else,764		} => {765			if evaluate(context.clone(), &cond.0)?766				.try_cast_bool("if condition should be boolean")?767			{768				evaluate(context, cond_then)?769			} else {770				match cond_else {771					Some(v) => evaluate(context, v)?,772					None => Val::Null,773				}774			}775		}776		Import(path) => {777			let mut tmp = loc778				.clone()779				.expect("imports can't be used without loc_data")780				.0;781			let import_location = Rc::make_mut(&mut tmp);782			import_location.pop();783			with_state(|s| s.import_file(&import_location, path))?784		}785		ImportStr(path) => {786			let mut tmp = loc787				.clone()788				.expect("imports can't be used without loc_data")789				.0;790			let import_location = Rc::make_mut(&mut tmp);791			import_location.pop();792			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)793		}794		Literal(LiteralType::Super) => return create_error(crate::error::Error::StandaloneSuper),795	})796}