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

1use crate::{2	context_creator, create_error, future_wrapper, lazy_val, push, with_state, Context,3	ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,4	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") => {506						assert_eq!(args.len(), 1);507						let expr = &args.get(0).unwrap().1;508						match evaluate(context, expr)? {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							v => panic!("can't get length of {:?}", v),518						}519					}520					// any521					("std", "type") => {522						assert_eq!(args.len(), 1);523						let expr = &args.get(0).unwrap().1;524						Val::Str(evaluate(context, expr)?.value_type()?.name().into())525					}526					// length, idx=>any527					("std", "makeArray") => {528						assert_eq!(args.len(), 2);529						if let (Val::Num(v), Val::Func(d)) = (530							evaluate(context.clone(), &args[0].1)?,531							evaluate(context, &args[1].1)?,532						) {533							assert!(v >= 0.0);534							let mut out = Vec::with_capacity(v as usize);535							for i in 0..v as usize {536								let call_ctx =537									Context::new().with_var("v".into(), Val::Num(i as f64))?;538								out.push(d.evaluate(539									call_ctx,540									&ArgsDesc(vec![Arg(None, el!(Expr::Var("v".into())))]),541									true,542								)?)543							}544							Val::Arr(Rc::new(out))545						} else {546							panic!("bad makeArray call");547						}548					}549					// string550					("std", "codepoint") => {551						assert_eq!(args.len(), 1);552						if let Val::Str(s) = evaluate(context, &args[0].1)? {553							assert!(554								s.chars().count() == 1,555								"std.codepoint should receive single char string"556							);557							Val::Num(s.chars().take(1).next().unwrap() as u32 as f64)558						} else {559							panic!("bad codepoint call");560						}561					}562					// object, includeHidden563					("std", "objectFieldsEx") => {564						assert_eq!(args.len(), 2);565						if let (Val::Obj(body), Val::Bool(include_hidden)) = (566							evaluate(context.clone(), &args[0].1)?,567							evaluate(context, &args[1].1)?,568						) {569							Val::Arr(Rc::new(570								body.fields_visibility()571									.into_iter()572									.filter(|(_k, v)| *v || include_hidden)573									.map(|(k, _v)| Val::Str(k))574									.collect(),575							))576						} else {577							panic!("bad objectFieldsEx call");578						}579					}580					// object, field, includeHidden581					("std", "objectHasEx") => {582						assert_eq!(args.len(), 3);583						if let (Val::Obj(body), Val::Str(name), Val::Bool(include_hidden)) = (584							evaluate(context.clone(), &args[0].1)?,585							evaluate(context.clone(), &args[1].1)?,586							evaluate(context, &args[2].1)?,587						) {588							Val::Bool(589								body.fields_visibility()590									.into_iter()591									.filter(|(_k, v)| *v || include_hidden)592									.any(|(k, _v)| *k == *name),593							)594						} else {595							panic!("bad objectHasEx call");596						}597					}598					("std", "primitiveEquals") => {599						assert_eq!(args.len(), 2);600						let (a, b) = (601							evaluate(context.clone(), &args[0].1)?,602							evaluate(context, &args[1].1)?,603						);604						Val::Bool(a == b)605					}606					("std", "modulo") => {607						assert_eq!(args.len(), 2);608						if let (Val::Num(a), Val::Num(b)) = (609							evaluate(context.clone(), &args[0].1)?,610							evaluate(context, &args[1].1)?,611						) {612							Val::Num(a % b)613						} else {614							panic!("bad modulo call");615						}616					}617					("std", "floor") => {618						assert_eq!(args.len(), 1);619						if let Val::Num(a) = evaluate(context, &args[0].1)? {620							Val::Num(a.floor())621						} else {622							panic!("bad floor call");623						}624					}625					("std", "trace") => {626						assert_eq!(args.len(), 2);627						if let (Val::Str(a), b) = (628							evaluate(context.clone(), &args[0].1)?,629							evaluate(context, &args[1].1)?,630						) {631							// TODO: Line numbers as in original jsonnet632							println!("TRACE: {}", a);633							b634						} else {635							panic!("bad trace call");636						}637					}638					("std", "pow") => {639						assert_eq!(args.len(), 2);640						if let (Val::Num(a), Val::Num(b)) = (641							evaluate(context.clone(), &args[0].1)?,642							evaluate(context, &args[1].1)?,643						) {644							Val::Num(a.powf(b))645						} else {646							panic!("bad pow call");647						}648					}649					("std", "extVar") => {650						assert_eq!(args.len(), 1);651						if let Val::Str(a) = evaluate(context, &args[0].1)? {652							with_state(|s| s.0.ext_vars.borrow().get(&a).cloned()).ok_or_else(653								|| {654									create_error::<()>(crate::Error::UndefinedExternalVariable(a))655										.err()656										.unwrap()657								},658							)?659						} else {660							panic!("bad extVar call");661						}662					}663					("std", "filter") => {664						assert_eq!(args.len(), 2);665						if let (Val::Func(predicate), Val::Arr(arr)) = (666							evaluate(context.clone(), &args[0].1)?,667							evaluate(context.clone(), &args[1].1)?,668						) {669							Val::Arr(Rc::new(670								arr.iter()671									.filter(|e| {672										predicate673											.evaluate_values(context.clone(), &[e.clone()])674											.unwrap()675											.try_cast_bool("filter predicate")676											.unwrap()677									})678									.cloned()679									.collect(),680							))681						} else {682							panic!("bad filter call");683						}684					}685					// faster686					("std", "join") => {687						assert_eq!(args.len(), 2);688						let joiner = evaluate(context.clone(), &args[0].1)?;689						let items = evaluate(context, &args[1].1)?;690						match (joiner.unwrap_if_lazy()?, items.unwrap_if_lazy()?) {691							(Val::Arr(joiner_items), Val::Arr(items)) => {692								// TODO: Minimal size should be known693								let mut out = Vec::new();694695								let mut first = true;696								for item in items.iter().cloned() {697									if let Val::Arr(items) = item.unwrap_if_lazy()? {698										if !first {699											out.reserve(joiner_items.len());700											out.extend(joiner_items.iter().cloned());701										}702										first = false;703										out.reserve(items.len());704										out.extend(items.iter().cloned());705									} else {706										panic!("all array items should be arrays")707									}708								}709710								Val::Arr(Rc::new(out))711							}712							(Val::Str(joiner), Val::Arr(items)) => {713								let mut out = String::new();714715								let mut first = true;716								for item in items.iter().cloned() {717									if let Val::Str(item) = item.unwrap_if_lazy()? {718										if !first {719											out += &joiner;720										}721										first = false;722										out += &item;723									} else {724										panic!("all array items should be strings")725									}726								}727728								Val::Str(out.into())729							}730							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),731						}732					}733					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),734				},735				Val::Func(f) => {736					let body = || f.evaluate(context, args, *tailstrict);737					if *tailstrict {738						body()?739					} else {740						push(loc, "function call", body)?741					}742				}743				_ => panic!("{:?} is not a function", value),744			}745		}746		Function(params, body) => evaluate_method(context, params.clone(), body.clone()),747		AssertExpr(AssertStmt(value, msg), returned) => {748			let assertion_result = push(&value.1, "assertion condition", || {749				evaluate(context.clone(), &value)?750					.try_cast_bool("assertion condition should be boolean")751			})?;752			if assertion_result {753				evaluate(context, returned)?754			} else if let Some(msg) = msg {755				panic!(756					"assertion failed ({:?}): {}",757					value,758					evaluate(context, msg)?.try_cast_str("assertion message should be string")?759				);760			} else {761				panic!("assertion failed ({:?}): no message", value);762			}763		}764		Error(e) => create_error(crate::Error::RuntimeError(765			evaluate(context, e)?.try_cast_str("error text should be string")?,766		))?,767		IfElse {768			cond,769			cond_then,770			cond_else,771		} => {772			if evaluate(context.clone(), &cond.0)?773				.try_cast_bool("if condition should be boolean")?774			{775				evaluate(context, cond_then)?776			} else {777				match cond_else {778					Some(v) => evaluate(context, v)?,779					None => Val::Null,780				}781			}782		}783		Import(path) => {784			let mut tmp = loc785				.clone()786				.expect("imports can't be used without loc_data")787				.0;788			let import_location = Rc::make_mut(&mut tmp);789			import_location.pop();790			with_state(|s| s.import_file(&import_location, path))?791		}792		ImportStr(path) => {793			let mut tmp = loc794				.clone()795				.expect("imports can't be used without loc_data")796				.0;797			let import_location = Rc::make_mut(&mut tmp);798			import_location.pop();799			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)800		}801		Literal(LiteralType::Super) => return create_error(crate::error::Error::StandaloneSuper),802	})803}