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

1use crate::{2	builtin::format::{format_arr, format_obj},3	context_creator, equals,4	error::Error::*,5	escape_string_json, future_wrapper, lazy_val, manifest_json_ex, parse_args, primitive_equals,6	push, throw, with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError,7	ObjMember, ObjValue, Result, Val, ValType,8};9use closure::closure;10use jrsonnet_parser::{11	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,12	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,13	Visibility,14};15use std::{cmp::Ordering, collections::HashMap, path::PathBuf, rc::Rc};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						b.name.clone(),28						params.clone(),29						b.value.clone(),30					)))31				))32			})),33		)34	} else {35		(36			b.name.clone(),37			LazyBinding::Bindable(Rc::new(move |this, super_obj| {38				Ok(lazy_val!(closure!(clone context_creator, clone b, ||39						evaluate_named(40							context_creator.0(this.clone(), super_obj.clone())?,41							&b.value,42							b.name.clone()43						)44				)))45			})),46		)47	}48}4950pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {51	Val::Func(Rc::new(FuncDesc {52		name,53		ctx,54		params,55		body,56	}))57}5859pub fn evaluate_field_name(60	context: Context,61	field_name: &jrsonnet_parser::FieldName,62) -> Result<Option<Rc<str>>> {63	Ok(match field_name {64		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),65		jrsonnet_parser::FieldName::Dyn(expr) => {66			let lazy = evaluate(context, expr)?;67			let value = lazy.unwrap_if_lazy()?;68			if matches!(value, Val::Null) {69				None70			} else {71				Some(value.try_cast_str("dynamic field name")?)72			}73		}74	})75}7677pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {78	Ok(match (op, b) {79		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,80		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),81		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),82		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),83		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),84	})85}8687pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {88	Ok(match (a, b) {89		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),9091		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)92		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),93		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),9495		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),96		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),9798		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),99		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),100		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,101		_ => throw!(BinaryOperatorDoesNotOperateOnValues(102			BinaryOpType::Add,103			a.value_type()?,104			b.value_type()?,105		)),106	})107}108109pub fn evaluate_binary_op_special(110	context: Context,111	a: &LocExpr,112	op: BinaryOpType,113	b: &LocExpr,114) -> Result<Val> {115	Ok(116		match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {117			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),118			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),119			(a, op, eb) => {120				evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?121			}122		},123	)124}125126pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {127	Ok(match (a, op, b) {128		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,129130		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),131132		// Bool X Bool133		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),134		(Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),135136		// Str X Str137		(Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),138		(Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),139		(Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),140		(Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),141142		// Num X Num143		(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,144		(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {145			if *v2 <= f64::EPSILON {146				throw!(DivisionByZero)147			}148			Val::new_checked_num(v1 / v2)?149		}150151		(Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,152153		(Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),154		(Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),155		(Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),156		(Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),157158		(Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {159			Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)160		}161		(Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {162			Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)163		}164		(Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {165			Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)166		}167		(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {168			if *v2 < 0.0 {169				throw!(RuntimeError("shift by negative exponent".into()))170			}171			Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)172		}173		(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {174			if *v2 < 0.0 {175				throw!(RuntimeError("shift by negative exponent".into()))176			}177			Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)178		}179180		_ => throw!(BinaryOperatorDoesNotOperateOnValues(181			op,182			a.value_type()?,183			b.value_type()?,184		)),185	})186}187188future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);189future_wrapper!(ObjValue, FutureObjValue);190191pub fn evaluate_comp<T>(192	context: Context,193	value: &impl Fn(Context) -> Result<T>,194	specs: &[CompSpec],195) -> Result<Option<Vec<T>>> {196	Ok(match specs.get(0) {197		None => Some(vec![value(context)?]),198		Some(CompSpec::IfSpec(IfSpecData(cond))) => {199			if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {200				evaluate_comp(context, value, &specs[1..])?201			} else {202				None203			}204		}205		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {206			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {207				Val::Arr(list) => {208					let mut out = Vec::new();209					for item in list.iter() {210						let item = item.unwrap_if_lazy()?;211						out.push(evaluate_comp(212							context.with_var(var.clone(), item.clone())?,213							value,214							&specs[1..],215						)?);216					}217					Some(out.into_iter().flatten().flatten().collect())218				}219				_ => throw!(InComprehensionCanOnlyIterateOverArray),220			}221		}222	})223}224225pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {226	let new_bindings = FutureNewBindings::new();227	let future_this = FutureObjValue::new();228	let context_creator = context_creator!(229		closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {230			Ok(context.extend_unbound(231				new_bindings.clone().unwrap(),232				context.dollar().clone().or_else(||this.clone()),233				Some(this.unwrap()),234				super_obj235			)?)236		})237	);238	{239		let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();240		for (n, b) in members241			.iter()242			.filter_map(|m| match m {243				Member::BindStmt(b) => Some(b.clone()),244				_ => None,245			})246			.map(|b| evaluate_binding(&b, context_creator.clone()))247		{248			bindings.insert(n, b);249		}250		new_bindings.fill(bindings);251	}252253	let mut new_members = HashMap::new();254	for member in members.iter() {255		match member {256			Member::Field(FieldMember {257				name,258				plus,259				params: None,260				visibility,261				value,262			}) => {263				let name = evaluate_field_name(context.clone(), &name)?;264				if name.is_none() {265					continue;266				}267				let name = name.unwrap();268				new_members.insert(269					name.clone(),270					ObjMember {271						add: *plus,272						visibility: *visibility,273						invoke: LazyBinding::Bindable(Rc::new(274							closure!(clone name, clone value, clone context_creator, |this, super_obj| {275								Ok(LazyVal::new_resolved(evaluate(276									context_creator.0(this, super_obj)?,277									&value,278								)?))279							}),280						)),281						location: value.1.clone(),282					},283				);284			}285			Member::Field(FieldMember {286				name,287				params: Some(params),288				value,289				..290			}) => {291				let name = evaluate_field_name(context.clone(), &name)?;292				if name.is_none() {293					continue;294				}295				let name = name.unwrap();296				new_members.insert(297					name.clone(),298					ObjMember {299						add: false,300						visibility: Visibility::Hidden,301						invoke: LazyBinding::Bindable(Rc::new(302							closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {303								// TODO: Assert304								Ok(LazyVal::new_resolved(evaluate_method(305									context_creator.0(this, super_obj)?,306									name.clone(),307									params.clone(),308									value.clone(),309								)))310							}),311						)),312						location: value.1.clone(),313					},314				);315			}316			Member::BindStmt(_) => {}317			Member::AssertStmt(_) => {}318		}319	}320	Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))321}322323pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {324	Ok(match object {325		ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,326		ObjBody::ObjComp(obj) => {327			let future_this = FutureObjValue::new();328			let mut new_members = HashMap::new();329			for (k, v) in evaluate_comp(330				context.clone(),331				&|ctx| {332					let new_bindings = FutureNewBindings::new();333					let context_creator = context_creator!(334						closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {335							Ok(context.extend_unbound(336								new_bindings.clone().unwrap(),337								context.dollar().clone().or_else(||this.clone()),338								None,339								super_obj340							)?)341						})342					);343					let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();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					let bindings = new_bindings.fill(bindings);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.extend(HashMap::new(), 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			future_this.fill(ObjValue::new(None, Rc::new(new_members)))385		}386	})387}388389/// Extracts code block and disables inlining for them390/// Fixes WASM to java bytecode compilation failing because of very large method391macro_rules! noinline {392	($e:expr) => {393		(#[inline(never)]394		move || $e)()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 lazy = evaluate(context.clone(), value)?;406	let value = lazy.unwrap_if_lazy()?;407	Ok(match value {408		Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {409			// arr/string/function410			("std", "length") => parse_args!(context, "std.length", args, 1, [411				0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];412			], {413				Ok(match x {414					Val::Str(n) => Val::Num(n.chars().count() as f64),415					Val::Arr(i) => Val::Num(i.len() as f64),416					Val::Obj(o) => Val::Num(417						o.fields_visibility()418							.into_iter()419							.filter(|(_k, v)| *v)420							.count() as f64,421					),422					_ => unreachable!(),423				})424			})?,425			// any426			("std", "type") => parse_args!(context, "std.type", args, 1, [427				0, x, vec![];428			], {429				Ok(Val::Str(x.value_type()?.name().into()))430			})?,431			// length, idx=>any432			("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [433				0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];434				1, func: [Val::Func]!!Val::Func, vec![ValType::Func];435			], {436				if sz < 0.0 {437					throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));438				}439				let mut out = Vec::with_capacity(sz as usize);440				for i in 0..sz as usize {441					out.push(func.evaluate_values(442						Context::new(),443						&[Val::Num(i as f64)]444					)?)445				}446				Ok(Val::Arr(Rc::new(out)))447			}))?,448			// string449			("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [450				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];451			], {452				assert!(453					str.chars().count() == 1,454					"std.codepoint should receive single char string"455				);456				Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))457			})?,458			// object, includeHidden459			("std", "objectFieldsEx") => {460				noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [461					0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];462					1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];463				], {464					let mut out = obj.fields_visibility()465						.into_iter()466						.filter(|(_k, v)| *v || inc_hidden)467						.map(|(k, _v)|k)468						.collect::<Vec<_>>();469					out.sort();470					Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))471				}))?472			}473			// object, field, includeHidden474			("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [475				0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];476				1, f: [Val::Str]!!Val::Str, vec![ValType::Str];477				2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];478			], {479				Ok(Val::Bool(480					obj.fields_visibility()481						.into_iter()482						.filter(|(_k, v)| *v || inc_hidden)483						.any(|(k, _v)| *k == *f),484				))485			})?,486			("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [487				0, a, vec![];488				1, b, vec![];489			], {490				Ok(Val::Bool(primitive_equals(&a, &b)?))491			})?,492			// faster493			("std", "equals") => parse_args!(context, "std.equals", args, 2, [494				0, a, vec![];495				1, b, vec![];496			], {497				Ok(Val::Bool(equals(&a, &b)?))498			})?,499			("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [500				0, a: [Val::Num]!!Val::Num, vec![ValType::Num];501				1, b: [Val::Num]!!Val::Num, vec![ValType::Num];502			], {503				Ok(Val::Num(a % b))504			})?,505			("std", "floor") => parse_args!(context, "std.floor", args, 1, [506				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];507			], {508				Ok(Val::Num(x.floor()))509			})?,510			("std", "log") => parse_args!(context, "std.log", args, 2, [511				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];512			], {513				Ok(Val::Num(n.ln()))514			})?,515			("std", "trace") => parse_args!(context, "std.trace", args, 2, [516				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];517				1, rest, vec![];518			], {519				eprint!("TRACE:");520				if let Some(loc) = loc {521					with_state(|s|{522						let locs = s.map_source_locations(&loc.0, &[loc.1]);523						eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);524					});525				}526				eprintln!(" {}", str);527				Ok(rest)528			})?,529			("std", "pow") => parse_args!(context, "std.modulo", args, 2, [530				0, x: [Val::Num]!!Val::Num, vec![ValType::Num];531				1, n: [Val::Num]!!Val::Num, vec![ValType::Num];532			], {533				Ok(Val::Num(x.powf(n)))534			})?,535			("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [536				0, x: [Val::Str]!!Val::Str, vec![ValType::Str];537			], {538				Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(539					|| UndefinedExternalVariable(x),540				)?)541			})?,542			("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [543				0, func: [Val::Func]!!Val::Func, vec![ValType::Func];544				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];545			], {546				Ok(Val::Arr(Rc::new(547					arr.iter()548						.cloned()549						.filter(|e| {550							func551								.evaluate_values(context.clone(), &[e.clone()])552								.unwrap()553								.try_cast_bool("filter predicate")554								.unwrap()555						})556						.collect(),557				)))558			}))?,559			// faster560			("std", "foldl") => noinline!(parse_args!(context, "std.foldl", args, 3, [561				0, func: [Val::Func]!!Val::Func, vec![ValType::Func];562				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];563				2, init, vec![];564			], {565				let mut acc = init;566				for i in arr.iter().cloned() {567					acc = func.evaluate_values(context.clone(), &[acc, i])?;568				}569				Ok(acc)570			}))?,571			// faster572			("std", "foldr") => noinline!(parse_args!(context, "std.foldr", args, 3, [573				0, func: [Val::Func]!!Val::Func, vec![ValType::Func];574				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];575				2, init, vec![];576			], {577				let mut acc = init;578				for i in arr.iter().rev().cloned() {579					acc = func.evaluate_values(context.clone(), &[acc, i])?;580				}581				Ok(acc)582			}))?,583			// faster584			#[allow(non_snake_case)]585			("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [586				0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];587				1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];588			], {589				if arr.len() <= 1 {590					return Ok(Val::Arr(arr))591				}592				let mut new_arr = arr.iter().cloned().collect::<Vec<_>>();593				match keyF.evaluate_values(context.clone(), &[new_arr[0].clone()])? {594					Val::Str(_) => {595						let mut err = None;596						new_arr.sort_by_cached_key(|k| {597							match keyF.evaluate_values(context.clone(), &[k.clone()]) {598								Ok(Val::Str(v)) => v,599								Ok(_) => {600									err = Some(LocError::new(RuntimeError("types of all array elements should equal".into())));601									"".into()602								}603								Err(e) => {604									err = Some(e);605									"".into()606								}607							}608						});609						if let Some(e) = err {610							return Err(e);611						}612					},613					Val::Num(_) => {614						let mut err = None;615						new_arr.sort_unstable_by(|a, b| {616							match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {617								(Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),618								(Ok(_a), Ok(_b)) => {619									err = Some(RuntimeError("types of all array elements should equal".into()).into());620									Ordering::Equal621								}622								(Err(e), _) | (_, Err(e)) => {623									err = Some(e);624									Ordering::Equal625								}626							}627						});628						if let Some(e) = err {629							return Err(e);630						}631					},632					_ => throw!(RuntimeError("keys should be number or string".into()))633				}634				Ok(Val::Arr(Rc::new(new_arr)))635			}))?,636			// faster637			("std", "format") => parse_args!(context, "std.format", args, 2, [638				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];639				1, vals, vec![]640			], {641				push(&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)), ||format!("std.format of {}", str), ||{642					Ok(match vals {643						Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),644						Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),645						o => Val::Str(format_arr(&str, &[o])?.into()),646					})647				})648			})?,649			// faster650			("std", "range") => parse_args!(context, "std.range", args, 2, [651				0, from: [Val::Num]!!Val::Num, vec![ValType::Num];652				0, to: [Val::Num]!!Val::Num, vec![ValType::Num];653			], {654				let mut out = Vec::with_capacity((1+to as usize-from as usize).max(0));655				for i in from as usize..=to as usize {656					out.push(Val::Num(i as f64));657				}658				Ok(Val::Arr(Rc::new(out)))659			})?,660			("std", "char") => parse_args!(context, "std.char", args, 1, [661				0, n: [Val::Num]!!Val::Num, vec![ValType::Num];662			], {663				let mut out = String::new();664				out.push(std::char::from_u32(n as u32).ok_or_else(||665					InvalidUnicodeCodepointGot(n as u32)666				)?);667				Ok(Val::Str(out.into()))668			})?,669			("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [670				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];671			], {672				Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))673			})?,674			("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [675				0, str: [Val::Str]!!Val::Str, vec![ValType::Str];676			], {677				Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))678			}))?,679			// faster680			("std", "base64") => parse_args!(context, "std.base64", args, 1, [681				0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];682			], {683				Ok(Val::Str(match input {684					Val::Str(s) => {685						base64::encode(s.bytes().collect::<Vec<_>>()).into()686					},687					Val::Arr(a) => {688						base64::encode(a.iter().map(|v| {689							Ok(v.clone().try_cast_num("base64 array")? as u8)690						}).collect::<Result<Vec<_>>>()?).into()691					},692					_ => unreachable!()693				}))694			})?,695			// faster696			("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [697				0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];698				1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];699			], {700				Ok(match sep {701					Val::Arr(joiner_items) => {702						let mut out = Vec::new();703704						let mut first = true;705						for item in arr.iter().cloned() {706							if let Val::Arr(items) = item.unwrap_if_lazy()? {707								if !first {708									out.reserve(joiner_items.len());709									out.extend(joiner_items.iter().cloned());710								}711								first = false;712								out.reserve(items.len());713								out.extend(items.iter().cloned());714							} else {715								throw!(RuntimeError("in std.join all items should be arrays".into()));716							}717						}718719						Val::Arr(Rc::new(out))720					},721					Val::Str(sep) => {722						let mut out = String::new();723724						let mut first = true;725						for item in arr.iter().cloned() {726							if let Val::Str(item) = item.unwrap_if_lazy()? {727								if !first {728									out += &sep;729								}730								first = false;731								out += &item;732							} else {733								throw!(RuntimeError("in std.join all items should be strings".into()));734							}735						}736737						Val::Str(out.into())738					},739					_ => unreachable!()740				})741			}))?,742			// Faster743			("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [744				0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];745			], {746				Ok(Val::Str(escape_string_json(&str_).into()))747			})?,748			// Faster749			("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [750				0, value, vec![];751				1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];752			], {753				Ok(Val::Str(manifest_json_ex(&value, &indent)?.into()))754			})?,755			(ns, name) => throw!(IntristicNotFound(ns.into(), name.into())),756		},757		Val::Func(f) => {758			let body = || f.evaluate(context, args, tailstrict);759			if tailstrict {760				body()?761			} else {762				push(loc, || format!("function <{}> call", f.name), body)?763			}764		}765		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),766	})767}768769pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {770	use Expr::*;771	let LocExpr(expr, _loc) = lexpr;772	Ok(match &**expr {773		Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),774		_ => evaluate(context, lexpr)?,775	})776}777778pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {779	use Expr::*;780	let LocExpr(expr, loc) = expr;781	Ok(match &**expr {782		Literal(LiteralType::This) => Val::Obj(783			context784				.this()785				.clone()786				.ok_or_else(|| CantUseSelfOutsideOfObject)?,787		),788		Literal(LiteralType::Dollar) => Val::Obj(789			context790				.dollar()791				.clone()792				.ok_or_else(|| NoTopLevelObjectFound)?,793		),794		Literal(LiteralType::True) => Val::Bool(true),795		Literal(LiteralType::False) => Val::Bool(false),796		Literal(LiteralType::Null) => Val::Null,797		Parened(e) => evaluate(context, e)?,798		Str(v) => Val::Str(v.clone()),799		Num(v) => Val::new_checked_num(*v)?,800		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,801		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,802		Var(name) => push(803			loc,804			|| format!("variable <{}>", name),805			|| Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),806		)?,807		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {808			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;809			context810				.super_obj()811				.clone()812				.expect("no super found")813				.get_raw(name, &context.this().clone().expect("no this found"))?814				.expect("value not found")815		}816		Index(value, index) => {817			match (818				evaluate(context.clone(), value)?.unwrap_if_lazy()?,819				evaluate(context, index)?,820			) {821				(Val::Obj(v), Val::Str(s)) => {822					if let Some(v) = v.get(s.clone())? {823						v.unwrap_if_lazy()?824					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {825						Val::Intristic(n, s)826					} else {827						throw!(NoSuchField(s))828					}829				}830				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(831					ValType::Obj,832					ValType::Str,833					n.value_type()?,834				)),835836				(Val::Arr(v), Val::Num(n)) => {837					if n.fract() > f64::EPSILON {838						throw!(FractionalIndex)839					}840					v.get(n as usize)841						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?842						.clone()843						.unwrap_if_lazy()?844				}845				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),846				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(847					ValType::Arr,848					ValType::Num,849					n.value_type()?,850				)),851852				(Val::Str(s), Val::Num(n)) => Val::Str(853					s.chars()854						.skip(n as usize)855						.take(1)856						.collect::<String>()857						.into(),858				),859				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(860					ValType::Str,861					ValType::Num,862					n.value_type()?,863				)),864865				(v, _) => throw!(CantIndexInto(v.value_type()?)),866			}867		}868		LocalExpr(bindings, returned) => {869			let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();870			let future_context = Context::new_future();871872			let context_creator = context_creator!(873				closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))874			);875876			for (k, v) in bindings877				.iter()878				.map(|b| evaluate_binding(b, context_creator.clone()))879			{880				new_bindings.insert(k, v);881			}882883			let context = context884				.extend_unbound(new_bindings, None, None, None)?885				.into_future(future_context);886			evaluate(context, &returned.clone())?887		}888		Arr(items) => {889			let mut out = Vec::with_capacity(items.len());890			for item in items {891				out.push(Val::Lazy(lazy_val!(892					closure!(clone context, clone item, || {893						evaluate(context.clone(), &item)894					})895				)));896			}897			Val::Arr(Rc::new(out))898		}899		ArrComp(expr, compspecs) => Val::Arr(900			// First compspec should be forspec, so no "None" possible here901			Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),902		),903		Obj(body) => Val::Obj(evaluate_object(context, body)?),904		ObjExtend(s, t) => evaluate_add_op(905			&evaluate(context.clone(), s)?,906			&Val::Obj(evaluate_object(context, t)?),907		)?,908		Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,909		Function(params, body) => {910			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())911		}912		AssertExpr(AssertStmt(value, msg), returned) => {913			let assertion_result = push(914				&value.1,915				|| "assertion condition".to_owned(),916				|| {917					evaluate(context.clone(), &value)?918						.try_cast_bool("assertion condition should be boolean")919				},920			)?;921			if assertion_result {922				evaluate(context, returned)?923			} else if let Some(msg) = msg {924				throw!(AssertionFailed(evaluate(context, msg)?));925			} else {926				throw!(AssertionFailed(Val::Null));927			}928		}929		ErrorStmt(e) => push(930			&loc,931			|| "error statement".to_owned(),932			|| {933				throw!(RuntimeError(934					evaluate(context, e)?.try_cast_str("error text should be string")?,935				))936			},937		)?,938		IfElse {939			cond,940			cond_then,941			cond_else,942		} => {943			if evaluate(context.clone(), &cond.0)?944				.try_cast_bool("if condition should be boolean")?945			{946				evaluate(context, cond_then)?947			} else {948				match cond_else {949					Some(v) => evaluate(context, v)?,950					None => Val::Null,951				}952			}953		}954		Import(path) => {955			let mut tmp = loc956				.clone()957				.expect("imports can't be used without loc_data")958				.0;959			let import_location = Rc::make_mut(&mut tmp);960			import_location.pop();961			push(962				loc,963				|| format!("import {:?}", path),964				|| with_state(|s| s.import_file(&import_location, path)),965			)?966		}967		ImportStr(path) => {968			let mut tmp = loc969				.clone()970				.expect("imports can't be used without loc_data")971				.0;972			let import_location = Rc::make_mut(&mut tmp);973			import_location.pop();974			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)975		}976		Literal(LiteralType::Super) => throw!(StandaloneSuper),977	})978}