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

5use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};5use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};
6use location::{offset_to_location, CodeLocation};6use location::{offset_to_location, CodeLocation};
7use std::env::current_dir;7use std::env::current_dir;
8use std::{collections::HashMap, path::PathBuf, str::FromStr};8use std::{collections::HashMap, path::PathBuf, str::FromStr, rc::Rc};
99
10enum Format {10enum Format {
11	None,11	None,
128		evaluator.with_stdlib();128		evaluator.with_stdlib();
129	}129	}
130	for ExtStr { name, value } in opts.ext_str.iter().cloned() {130	for ExtStr { name, value } in opts.ext_str.iter().cloned() {
131		evaluator.add_ext_var(name, Val::Str(value));131		evaluator.add_ext_var(name.into(), Val::Str(value.into()));
132	}132	}
133	for ExtStr { name, value } in opts.ext_code.iter().cloned() {133	for ExtStr { name, value } in opts.ext_code.iter().cloned() {
134		evaluator.add_ext_var(name, evaluator.parse_evaluate_raw(&value).unwrap());134		evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());
135	}135	}
136	let mut input = current_dir().unwrap();136	let mut input = current_dir().unwrap();
137	input.push(opts.input.clone());137	input.push(opts.input.clone());
147				Val::Func(f) => {147				Val::Func(f) => {
148					let mut desc_map = HashMap::new();148					let mut desc_map = HashMap::new();
149					for ExtStr { name, value } in opts.tla_str.iter().cloned() {149					for ExtStr { name, value } in opts.tla_str.iter().cloned() {
150						desc_map.insert(name, el!(Expr::Str(value)));150						desc_map.insert(name, el!(Expr::Str(value.into())));
151					}151					}
152					for ExtStr { name, value } in opts.tla_code.iter().cloned() {152					for ExtStr { name, value } in opts.tla_code.iter().cloned() {
153						desc_map.insert(153						desc_map.insert(
154							name,154							name,
155							jsonnet_parser::parse(155							jsonnet_parser::parse(
156								&value,156								&value,
157								&ParserSettings {157								&ParserSettings {
158									file_name: PathBuf::new(),158									file_name: Rc::new(PathBuf::new()),
159									loc_data: false,159									loc_data: false,
160								},160								},
161							)161							)
162							.unwrap(),162							.unwrap(),
163						);163						);
164					}164					}
165					evaluator.add_global("__tmp__tlf__".to_owned(), Val::Func(f));165					evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));
166					evaluator166					evaluator
167						.evaluate_raw(el!(Expr::Apply(167						.evaluate_raw(el!(Expr::Apply(
168							el!(Expr::Var("__tmp__tlf__".to_owned())),168							el!(Expr::Var("__tmp__tlf__".into())),
169							ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),169							ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),
170							false,170							false,
171						)))171						)))
178					if opts.no_stdlib {178					if opts.no_stdlib {
179						evaluator.with_stdlib();179						evaluator.with_stdlib();
180					}180					}
181					evaluator.add_global("__tmp__to_json__".to_owned(), v);181					evaluator.add_global("__tmp__to_json__".into(), v);
182					let v = evaluator.parse_evaluate_raw(&format!(182					let v = evaluator.parse_evaluate_raw(&format!(
183						"std.manifestJsonEx(__tmp__to_json__, \"{}\")",183						"std.manifestJsonEx(__tmp__to_json__, \"{}\")",
184						" ".repeat(opts.line_padding),184						" ".repeat(opts.line_padding),
195					if opts.no_stdlib {195					if opts.no_stdlib {
196						evaluator.with_stdlib();196						evaluator.with_stdlib();
197					}197					}
198					evaluator.add_global("__tmp__to_yaml__".to_owned(), v);198					evaluator.add_global("__tmp__to_yaml__".into(), v);
199					let v = evaluator199					let v = evaluator
200						.parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \"  \")");200						.parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \"  \")");
201					match v {201					match v {

34								Member::Field(FieldMember {34								Member::Field(FieldMember {
35									name: FieldName::Fixed(name),35									name: FieldName::Fixed(name),
36									..36									..
37								}) if name == "join"37								}) if **name == *"join"
38							)38							)
39						})39						})
40						.collect(),40						.collect(),

16	dollar: Option<ObjValue>,16	dollar: Option<ObjValue>,
17	this: Option<ObjValue>,17	this: Option<ObjValue>,
18	super_obj: Option<ObjValue>,18	super_obj: Option<ObjValue>,
19	bindings: LayeredHashMap<String, LazyVal>,19	bindings: LayeredHashMap<Rc<str>, LazyVal>,
20}20}
21pub struct Context(Rc<ContextInternals>);21pub struct Context(Rc<ContextInternals>);
22impl Debug for Context {22impl Debug for Context {
53		}))53		}))
54	}54	}
5555
56	pub fn binding(&self, name: &str) -> Result<LazyVal> {56	pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {
57		self.0.bindings.get(name).cloned().ok_or_else(|| {57		self.0.bindings.get(&name).cloned().ok_or_else(|| {
58			create_error::<()>(Error::UnknownVariable(name.to_owned()))58			create_error::<()>(Error::UnknownVariable(name))
59				.err()59				.err()
60				.unwrap()60				.unwrap()
61		})61		})
67		ctx.unwrap()67		ctx.unwrap()
68	}68	}
6969
70	pub fn with_var(&self, name: String, value: Val) -> Result<Context> {70	pub fn with_var(&self, name: Rc<str>, value: Val) -> Result<Context> {
71		let mut new_bindings = HashMap::with_capacity(1);71		let mut new_bindings = HashMap::with_capacity(1);
72		new_bindings.insert(name, resolved_lazy_val!(value));72		new_bindings.insert(name, resolved_lazy_val!(value));
73		self.extend(new_bindings, None, None, None)73		self.extend(new_bindings, None, None, None)
74	}74	}
7575
76	pub fn extend(76	pub fn extend(
77		&self,77		&self,
78		new_bindings: HashMap<String, LazyVal>,78		new_bindings: HashMap<Rc<str>, LazyVal>,
79		new_dollar: Option<ObjValue>,79		new_dollar: Option<ObjValue>,
80		new_this: Option<ObjValue>,80		new_this: Option<ObjValue>,
81		new_super_obj: Option<ObjValue>,81		new_super_obj: Option<ObjValue>,
97	}97	}
98	pub fn extend_unbound(98	pub fn extend_unbound(
99		&self,99		&self,
100		new_bindings: HashMap<String, LazyBinding>,100		new_bindings: HashMap<Rc<str>, LazyBinding>,
101		new_dollar: Option<ObjValue>,101		new_dollar: Option<ObjValue>,
102		new_this: Option<ObjValue>,102		new_this: Option<ObjValue>,
103		new_super_obj: Option<ObjValue>,103		new_super_obj: Option<ObjValue>,

6pub enum Error {6pub enum Error {
7	VariableIsNotDefined(String),7	VariableIsNotDefined(String),
8	TypeMismatch(&'static str, Vec<ValType>, ValType),8	TypeMismatch(&'static str, Vec<ValType>, ValType),
9	NoSuchField(String),9	NoSuchField(Rc<str>),
1010
11	UnknownVariable(String),11	UnknownVariable(Rc<str>),
1212
13	UnknownFunctionParameter(String),13	UnknownFunctionParameter(String),
14	BindingParameterASecondTime(String),14	BindingParameterASecondTime(Rc<str>),
15	TooManyArgsFunctionHas(usize),15	TooManyArgsFunctionHas(usize),
16	FunctionParameterNotBoundInCall(String),16	FunctionParameterNotBoundInCall(Rc<str>),
1717
18	UndefinedExternalVariable(String),18	UndefinedExternalVariable(Rc<str>),
1919
20	FieldMustBeStringGot(ValType),20	FieldMustBeStringGot(ValType),
2121
22	AttemptedIndexAnArrayWithString(String),22	AttemptedIndexAnArrayWithString(Rc<str>),
23	ValueIndexMustBeTypeGot(ValType, ValType, ValType),23	ValueIndexMustBeTypeGot(ValType, ValType, ValType),
24	CantIndexInto(ValType),24	CantIndexInto(ValType),
2525
31	ImportNotSupported(PathBuf, PathBuf),31	ImportNotSupported(PathBuf, PathBuf),
32	ImportSyntaxError(jsonnet_parser::ParseError),32	ImportSyntaxError(jsonnet_parser::ParseError),
3333
34	RuntimeError(String),34	RuntimeError(Rc<str>),
35	StackOverflow,35	StackOverflow,
36	FractionalIndex,36	FractionalIndex,
37	DivisionByZero,37	DivisionByZero,

14	rc::Rc,14	rc::Rc,
15};15};
1616
17pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (String, LazyBinding) {17pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {
18	let b = b.clone();18	let b = b.clone();
19	if let Some(params) = &b.params {19	if let Some(params) = &b.params {
20		let params = params.clone();20		let params = params.clone();
54pub fn evaluate_field_name(54pub fn evaluate_field_name(
55	context: Context,55	context: Context,
56	field_name: &jsonnet_parser::FieldName,56	field_name: &jsonnet_parser::FieldName,
57) -> Result<Option<String>> {57) -> Result<Option<Rc<str>>> {
58	Ok(match field_name {58	Ok(match field_name {
59		jsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),59		jsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
60		jsonnet_parser::FieldName::Dyn(expr) => {60		jsonnet_parser::FieldName::Dyn(expr) => {
61			let value = evaluate(context, expr)?.unwrap_if_lazy()?;61			let lazy = evaluate(context, expr)?;
62			let value = lazy.unwrap_if_lazy()?;
62			if matches!(value, Val::Null) {63			if matches!(value, Val::Null) {
63				None64				None
64			} else {65			} else {
8081
81pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {82pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {
82	Ok(match (a, b) {83	Ok(match (a, b) {
83		(Val::Str(v1), Val::Str(v2)) => Val::Str(v1.to_owned() + &v2),84		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),
8485
85		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)86		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)
86		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o)),87		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),
87		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n)),88		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),
8889
89		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?)),90		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),
90		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s)),91		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),
9192
92		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),93		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
93		(Val::Arr(a), Val::Arr(b)) => Val::Arr([&a[..], &b[..]].concat()),94		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
94		(Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),95		(Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),
95		_ => panic!("can't add: {:?} and {:?}", a, b),96		_ => panic!("can't add: {:?} and {:?}", a, b),
96	})97	})
117	Ok(match (a, op, b) {118	Ok(match (a, op, b) {
118		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,119		(a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,
119120
120		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize)),121		(Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),
121122
122		// Bool X Bool123		// Bool X Bool
123		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),124		(Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),
165	})166	})
166}167}
167168
168future_wrapper!(HashMap<String, LazyBinding>, FutureNewBindings);169future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);
169future_wrapper!(ObjValue, FutureObjValue);170future_wrapper!(ObjValue, FutureObjValue);
170171
171pub fn evaluate_comp<T>(172pub fn evaluate_comp<T>(
186			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {187			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {
187				Val::Arr(list) => {188				Val::Arr(list) => {
188					let mut out = Vec::new();189					let mut out = Vec::new();
189					for item in list {190					for item in list.iter() {
190						let item = item.clone().unwrap_if_lazy()?;191						let item = item.unwrap_if_lazy()?;
191						out.push(evaluate_comp(192						out.push(evaluate_comp(
192							context.with_var(var.clone(), item)?,193							context.with_var(var.clone(), item.clone())?,
193							value,194							value,
194							&specs[1..],195							&specs[1..],
195						)?);196						)?);
202	})203	})
203}204}
204205
206pub 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_obj
216			)?)
217		})
218	);
219	{
220		let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
221		for (n, b) in members
222			.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	}
233
234	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| {
205// TODO: Asserts286								// TODO: Assert
287								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}
303
206pub fn evaluate_object(context: Context, object: ObjBody) -> Result<ObjValue> {304pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {
207	Ok(match object {305	Ok(match object {
208		ObjBody::MemberList(members) => {306		ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,
209			let new_bindings = FutureNewBindings::new();
210			let future_this = FutureObjValue::new();
211			let context_creator = context_creator!(
212				closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {
213					Ok(context.extend_unbound(
214						new_bindings.clone().unwrap(),
215						context.dollar().clone().or_else(||this.clone()),
216						Some(this.unwrap()),
217						super_obj
218					)?)
219				})
220			);
221			{
222				let mut bindings: HashMap<String, LazyBinding> = HashMap::new();
223				for (n, b) in members
224					.iter()
225					.filter_map(|m| match m {
226						Member::BindStmt(b) => Some(b.clone()),
227						_ => None,
228					})
229					.map(|b| evaluate_binding(&b, context_creator.clone()))
230				{
231					bindings.insert(n, b);
232				}
233				new_bindings.fill(bindings);
234			}
235
236			let mut new_members = BTreeMap::new();
237			for member in members.into_iter() {
238				match member {
239					Member::Field(FieldMember {
240						name,
241						plus,
242						params: None,
243						visibility,
244						value,
245					}) => {
246						let name = evaluate_field_name(context.clone(), &name)?;
247						if name.is_none() {
248							continue;
249						}
250						let name = name.unwrap();
251						new_members.insert(
252							name.clone(),
253							ObjMember {
254								add: plus,
255								visibility: visibility.clone(),
256								invoke: LazyBinding::Bindable(Rc::new(
257									closure!(clone name, clone value, clone context_creator, |this, super_obj| {
258										Ok(LazyVal::new_resolved(push(&value.1, "object field", ||{
259											let context = context_creator.0(this, super_obj)?;
260											evaluate(
261												context,
262												&value,
263											)?.unwrap_if_lazy()
264										})?))
265									}),
266								)),
267							},
268						);
269					}
270					Member::Field(FieldMember {
271						name,
272						params: Some(params),
273						value,
274						..
275					}) => {
276						let name = evaluate_field_name(context.clone(), &name)?;
277						if name.is_none() {
278							continue;
279						}
280						let name = name.unwrap();
281						new_members.insert(
282							name,
283							ObjMember {
284								add: false,
285								visibility: Visibility::Hidden,
286								invoke: LazyBinding::Bindable(Rc::new(
287									closure!(clone value, clone context_creator, |this, super_obj| {
288										// TODO: Assert
289										Ok(LazyVal::new_resolved(evaluate_method(
290											context_creator.0(this, super_obj)?,
291											params.clone(),
292											value.clone(),
293										)))
294									}),
295								)),
296							},
297						);
298					}
299					Member::BindStmt(_) => {}
300					Member::AssertStmt(_) => {}
301				}
302			}
303			future_this.fill(ObjValue::new(None, Rc::new(new_members)))
304		}
305		ObjBody::ObjComp {307		ObjBody::ObjComp(obj) => {
306			pre_locals,
307			key,
308			value,
309			post_locals,
310			compspecs,
311		} => {
312			let future_this = FutureObjValue::new();308			let future_this = FutureObjValue::new();
313			let mut new_members = BTreeMap::new();309			let mut new_members = BTreeMap::new();
314			for (k, v) in evaluate_comp(310			for (k, v) in evaluate_comp(
325							)?)321							)?)
326						})322						})
327					);323					);
328					let mut bindings: HashMap<String, LazyBinding> = HashMap::new();324					let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
329					for (n, b) in pre_locals325					for (n, b) in obj
326						.pre_locals
330						.iter()327						.iter()
331						.chain(post_locals.iter())328						.chain(obj.post_locals.iter())
332						.map(|b| evaluate_binding(b, context_creator.clone()))329						.map(|b| evaluate_binding(b, context_creator.clone()))
333					{330					{
334						bindings.insert(n, b);331						bindings.insert(n, b);
335					}332					}
336					let bindings = new_bindings.fill(bindings);333					let bindings = new_bindings.fill(bindings);
337					let ctx = ctx.extend_unbound(bindings, None, None, None)?;334					let ctx = ctx.extend_unbound(bindings, None, None, None)?;
338					let key = evaluate(ctx.clone(), &key)?;335					let key = evaluate(ctx.clone(), &obj.key)?;
339					let value = LazyBinding::Bindable(Rc::new(336					let value = LazyBinding::Bindable(Rc::new(
340						closure!(clone ctx, clone value, |this, _super_obj| {337						closure!(clone ctx, clone obj.value, |this, _super_obj| {
341							Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))338							Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))
342						}),339						}),
343					));340					));
344341
345					Ok((key, value))342					Ok((key, value))
346				},343				},
347				&compspecs,344				&obj.compspecs,
348			)?345			)?
349			.unwrap()346			.unwrap()
350			{347			{
394		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,391		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,
395		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,392		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,
396		Var(name) => push(loc, "var", || {393		Var(name) => push(loc, "var", || {
397			Val::Lazy(context.binding(&name)?).unwrap_if_lazy()394			Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?)
398		})?,395		})?,
399		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {396		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {
400			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;397			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;
411				evaluate(context, index)?,408				evaluate(context, index)?,
412			) {409			) {
413				(Val::Obj(v), Val::Str(s)) => {410				(Val::Obj(v), Val::Str(s)) => {
414					if let Some(v) = v.get(&s)? {411					if let Some(v) = v.get(s.clone())? {
415						v.unwrap_if_lazy()?412						v.unwrap_if_lazy()?
416					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__")? {413					} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {
417						Val::Intristic(n, s)414						Val::Intristic(n, s)
418					} else {415					} else {
419						create_error(crate::Error::NoSuchField(s))?416						create_error(crate::Error::NoSuchField(s))?
443					n.value_type()?,440					n.value_type()?,
444				))?,441				))?,
445442
446				(Val::Str(s), Val::Num(n)) => {443				(Val::Str(s), Val::Num(n)) => Val::Str(
447					Val::Str(s.chars().skip(n as usize).take(1).collect())444					s.chars()
448				}445						.skip(n as usize)
446						.take(1)
447						.collect::<String>()
448						.into(),
449				),
449				(Val::Str(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(450				(Val::Str(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(
450					ValType::Str,451					ValType::Str,
451					ValType::Num,452					ValType::Num,
456			}457			}
457		}458		}
458		LocalExpr(bindings, returned) => {459		LocalExpr(bindings, returned) => {
459			let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();460			let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
460			let future_context = Context::new_future();461			let future_context = Context::new_future();
461462
462			let context_creator = context_creator!(463			let context_creator = context_creator!(
484					})485					})
485				)));486				)));
486			}487			}
487			Val::Arr(out)488			Val::Arr(Rc::new(out))
488		}489		}
489		ArrComp(expr, compspecs) => Val::Arr(490		ArrComp(expr, compspecs) => Val::Arr(
490			// First compspec should be forspec, so no "None" possible here491			// First compspec should be forspec, so no "None" possible here
491			evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap(),492			Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),
492		),493		),
493		Obj(body) => Val::Obj(evaluate_object(context, body.clone())?),494		Obj(body) => Val::Obj(evaluate_object(context, body)?),
494		ObjExtend(s, t) => evaluate_add_op(495		ObjExtend(s, t) => evaluate_add_op(
495			&evaluate(context.clone(), s)?,496			&evaluate(context.clone(), s)?,
496			&Val::Obj(evaluate_object(context, t.clone())?),497			&Val::Obj(evaluate_object(context, t)?),
497		)?,498		)?,
498		Apply(value, args, tailstrict) => {499		Apply(value, args, tailstrict) => {
499			let value = evaluate(context.clone(), value)?.unwrap_if_lazy()?;500			let lazy = evaluate(context.clone(), value)?;
501			let value = lazy.unwrap_if_lazy()?;
500			match value {502			match value {
501				Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {503				Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {
502					// arr/string/function504					// arr/string/function
519					("std", "type") => {521					("std", "type") => {
520						assert_eq!(args.len(), 1);522						assert_eq!(args.len(), 1);
521						let expr = &args.get(0).unwrap().1;523						let expr = &args.get(0).unwrap().1;
522						Val::Str(evaluate(context, expr)?.value_type()?.name().to_owned())524						Val::Str(evaluate(context, expr)?.value_type()?.name().into())
523					}525					}
524					// length, idx=>any526					// length, idx=>any
525					("std", "makeArray") => {527					("std", "makeArray") => {
532							let mut out = Vec::with_capacity(v as usize);534							let mut out = Vec::with_capacity(v as usize);
533							for i in 0..v as usize {535							for i in 0..v as usize {
534								let call_ctx =536								let call_ctx =
535									Context::new().with_var("v".to_owned(), Val::Num(i as f64))?;537									Context::new().with_var("v".into(), Val::Num(i as f64))?;
536								out.push(d.evaluate(538								out.push(d.evaluate(
537									call_ctx,539									call_ctx,
538									&ArgsDesc(vec![Arg(None, el!(Expr::Var("v".to_owned())))]),540									&ArgsDesc(vec![Arg(None, el!(Expr::Var("v".into())))]),
539									true,541									true,
540								)?)542								)?)
541							}543							}
542							Val::Arr(out)544							Val::Arr(Rc::new(out))
543						} else {545						} else {
544							panic!("bad makeArray call");546							panic!("bad makeArray call");
545						}547						}
564							evaluate(context.clone(), &args[0].1)?,566							evaluate(context.clone(), &args[0].1)?,
565							evaluate(context, &args[1].1)?,567							evaluate(context, &args[1].1)?,
566						) {568						) {
567							Val::Arr(569							Val::Arr(Rc::new(
568								body.fields_visibility()570								body.fields_visibility()
569									.into_iter()571									.into_iter()
570									.filter(|(_k, v)| *v || include_hidden)572									.filter(|(_k, v)| *v || include_hidden)
571									.map(|(k, _v)| Val::Str(k))573									.map(|(k, _v)| Val::Str(k))
572									.collect(),574									.collect(),
573							)575							))
574						} else {576						} else {
575							panic!("bad objectFieldsEx call");577							panic!("bad objectFieldsEx call");
576						}578						}
587								body.fields_visibility()589								body.fields_visibility()
588									.into_iter()590									.into_iter()
589									.filter(|(_k, v)| *v || include_hidden)591									.filter(|(_k, v)| *v || include_hidden)
590									.any(|(k, _v)| k == name),592									.any(|(k, _v)| *k == *name),
591							)593							)
592						} else {594						} else {
593							panic!("bad objectHasEx call");595							panic!("bad objectHasEx call");
664							evaluate(context.clone(), &args[0].1)?,666							evaluate(context.clone(), &args[0].1)?,
665							evaluate(context.clone(), &args[1].1)?,667							evaluate(context.clone(), &args[1].1)?,
666						) {668						) {
667							Val::Arr(669							Val::Arr(Rc::new(
668								arr.into_iter()670								arr.iter()
669									.filter(|e| {671									.filter(|e| {
670										predicate672										predicate
671											.evaluate_values(context.clone(), &[e.clone()])673											.evaluate_values(context.clone(), &[e.clone()])
672											.unwrap()674											.unwrap()
673											.try_cast_bool("filter predicate")675											.try_cast_bool("filter predicate")
674											.unwrap()676											.unwrap()
675									})677									})
678									.cloned()
676									.collect(),679									.collect(),
677							)680							))
678						} else {681						} else {
679							panic!("bad filter call");682							panic!("bad filter call");
680						}683						}
681					}684					}
682					// faster685					// faster
683					("std", "join") => {686					("std", "join") => {
684						assert_eq!(args.len(), 2);687						assert_eq!(args.len(), 2);
685						let joiner = evaluate(context.clone(), &args[0].1)?.unwrap_if_lazy()?;688						let joiner = evaluate(context.clone(), &args[0].1)?;
686						let items = evaluate(context, &args[1].1)?.unwrap_if_lazy()?;689						let items = evaluate(context, &args[1].1)?;
687						match (joiner, items) {690						match (joiner.unwrap_if_lazy()?, items.unwrap_if_lazy()?) {
688							(Val::Arr(joiner_items), Val::Arr(items)) => {691							(Val::Arr(joiner_items), Val::Arr(items)) => {
689								// TODO: Minimal size should be known692								// TODO: Minimal size should be known
690								let mut out = Vec::new();693								let mut out = Vec::new();
691694
692								let mut first = true;695								let mut first = true;
693								for item in items {696								for item in items.iter().cloned() {
694									if let Val::Arr(items) = item.unwrap_if_lazy()? {697									if let Val::Arr(items) = item.unwrap_if_lazy()? {
695										if !first {698										if !first {
699											out.reserve(joiner_items.len());
696											out.extend(joiner_items.iter().cloned());700											out.extend(joiner_items.iter().cloned());
697										}701										}
698										first = false;702										first = false;
703										out.reserve(items.len());
699										out.extend(items);704										out.extend(items.iter().cloned());
700									} else {705									} else {
701										panic!("all array items should be arrays")706										panic!("all array items should be arrays")
702									}707									}
703								}708								}
704709
705								Val::Arr(out)710								Val::Arr(Rc::new(out))
706							}711							}
707							(Val::Str(joiner), Val::Arr(items)) => {712							(Val::Str(joiner), Val::Arr(items)) => {
708								let mut out = String::new();713								let mut out = String::new();
709714
710								let mut first = true;715								let mut first = true;
711								for item in items {716								for item in items.iter().cloned() {
712									if let Val::Str(item) = item.unwrap_if_lazy()? {717									if let Val::Str(item) = item.unwrap_if_lazy()? {
713										if !first {718										if !first {
714											out += &joiner;719											out += &joiner;
720									}725									}
721								}726								}
722727
723								Val::Str(out)728								Val::Str(out.into())
724							}729							}
725							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),730							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),
726						}731						}
776			}781			}
777		}782		}
778		Import(path) => {783		Import(path) => {
779			let mut import_location = loc784			let mut tmp = loc
780				.clone()785				.clone()
781				.expect("imports can't be used without loc_data")786				.expect("imports can't be used without loc_data")
782				.0787				.0;
783				.clone();788			let import_location = Rc::make_mut(&mut tmp);
784			import_location.pop();789			import_location.pop();
785			with_state(|s| s.import_file(&import_location, path))?790			with_state(|s| s.import_file(&import_location, path))?
786		}791		}
787		ImportStr(path) => {792		ImportStr(path) => {
788			let mut import_location = loc793			let mut tmp = loc
789				.clone()794				.clone()
790				.expect("imports can't be used without loc_data")795				.expect("imports can't be used without loc_data")
791				.0796				.0;
792				.clone();797			let import_location = Rc::make_mut(&mut tmp);
793			import_location.pop();798			import_location.pop();
794			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)799			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)
795		}800		}