1use crate::{2 context_creator, create_error, create_error_result, escape_string_json, future_wrapper,3 lazy_val, manifest_json_ex, parse_args, push, with_state, Context, ContextCreator, Error,4 FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val, ValType,5};6use closure::closure;7use jrsonnet_parser::{8 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,9 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,10 Visibility,11};12use std::{collections::HashMap, rc::Rc};1314pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {15 let b = b.clone();16 if let Some(params) = &b.params {17 let params = params.clone();18 (19 b.name.clone(),20 LazyBinding::Bindable(Rc::new(move |this, super_obj| {21 Ok(lazy_val!(22 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(23 context_creator.0(this.clone(), super_obj.clone())?,24 params.clone(),25 b.value.clone(),26 )))27 ))28 })),29 )30 } else {31 (32 b.name.clone(),33 LazyBinding::Bindable(Rc::new(move |this, super_obj| {34 Ok(lazy_val!(closure!(clone context_creator, clone b, ||35 push(&b.value.1, "thunk", ||{36 evaluate(37 context_creator.0(this.clone(), super_obj.clone())?,38 &b.value39 )40 })41 )))42 })),43 )44 }45}4647pub fn evaluate_method(ctx: Context, params: ParamsDesc, body: LocExpr) -> Val {48 Val::Func(FuncDesc { ctx, params, body })49}5051pub fn evaluate_field_name(52 context: Context,53 field_name: &jrsonnet_parser::FieldName,54) -> Result<Option<Rc<str>>> {55 Ok(match field_name {56 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),57 jrsonnet_parser::FieldName::Dyn(expr) => {58 let lazy = evaluate(context, expr)?;59 let value = lazy.unwrap_if_lazy()?;60 if matches!(value, Val::Null) {61 None62 } else {63 Some(value.try_cast_str("dynamic field name")?)64 }65 }66 })67}6869pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {70 Ok(match (op, b) {71 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,72 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),73 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),74 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),75 (op, o) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(76 op,77 o.value_type()?,78 ))?,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 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::new_checked_num(v1 + v2)?,96 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(97 BinaryOpType::Add,98 a.value_type()?,99 b.value_type()?,100 ))?,101 })102}103104pub fn evaluate_binary_op_special(105 context: Context,106 a: &LocExpr,107 op: BinaryOpType,108 b: &LocExpr,109) -> Result<Val> {110 Ok(111 match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {112 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),113 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),114 (a, op, eb) => {115 evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?116 }117 },118 )119}120121pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {122 Ok(match (a, op, b) {123 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,124125 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),126127 128 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),129 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),130131 132 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),133 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),134 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),135 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),136137 138 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,139 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {140 if *v2 <= f64::EPSILON {141 create_error_result(crate::Error::DivisionByZero)?142 }143 Val::new_checked_num(v1 / v2)?144 }145146 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,147148 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),149 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),150 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),151 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),152153 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {154 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)155 }156 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {157 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)158 }159 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {160 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)161 }162 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {163 if *v2 < 0.0 {164 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?165 }166 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)167 }168 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {169 if *v2 < 0.0 {170 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?171 }172 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)173 }174175 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(176 op,177 a.value_type()?,178 b.value_type()?,179 ))?,180 })181}182183future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);184future_wrapper!(ObjValue, FutureObjValue);185186pub fn evaluate_comp<T>(187 context: Context,188 value: &impl Fn(Context) -> Result<T>,189 specs: &[CompSpec],190) -> Result<Option<Vec<T>>> {191 Ok(match specs.get(0) {192 None => Some(vec![value(context)?]),193 Some(CompSpec::IfSpec(IfSpecData(cond))) => {194 if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {195 evaluate_comp(context, value, &specs[1..])?196 } else {197 None198 }199 }200 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {201 match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {202 Val::Arr(list) => {203 let mut out = Vec::new();204 for item in list.iter() {205 let item = item.unwrap_if_lazy()?;206 out.push(evaluate_comp(207 context.with_var(var.clone(), item.clone())?,208 value,209 &specs[1..],210 )?);211 }212 Some(out.into_iter().flatten().flatten().collect())213 }214 _ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,215 }216 }217 })218}219220pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {221 let new_bindings = FutureNewBindings::new();222 let future_this = FutureObjValue::new();223 let context_creator = context_creator!(224 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {225 Ok(context.extend_unbound(226 new_bindings.clone().unwrap(),227 context.dollar().clone().or_else(||this.clone()),228 Some(this.unwrap()),229 super_obj230 )?)231 })232 );233 {234 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();235 for (n, b) in members236 .iter()237 .filter_map(|m| match m {238 Member::BindStmt(b) => Some(b.clone()),239 _ => None,240 })241 .map(|b| evaluate_binding(&b, context_creator.clone()))242 {243 bindings.insert(n, b);244 }245 new_bindings.fill(bindings);246 }247248 let mut new_members = HashMap::new();249 for member in members.iter() {250 match member {251 Member::Field(FieldMember {252 name,253 plus,254 params: None,255 visibility,256 value,257 }) => {258 let name = evaluate_field_name(context.clone(), &name)?;259 if name.is_none() {260 continue;261 }262 let name = name.unwrap();263 new_members.insert(264 name.clone(),265 ObjMember {266 add: *plus,267 visibility: *visibility,268 invoke: LazyBinding::Bindable(Rc::new(269 closure!(clone name, clone value, clone context_creator, |this, super_obj| {270 Ok(LazyVal::new_resolved(push(&value.1, "object field", ||{271 let context = context_creator.0(this, super_obj)?;272 evaluate(273 context,274 &value,275 )276 })?))277 }),278 )),279 location: value.1.clone(),280 },281 );282 }283 Member::Field(FieldMember {284 name,285 params: Some(params),286 value,287 ..288 }) => {289 let name = evaluate_field_name(context.clone(), &name)?;290 if name.is_none() {291 continue;292 }293 let name = name.unwrap();294 new_members.insert(295 name,296 ObjMember {297 add: false,298 visibility: Visibility::Hidden,299 invoke: LazyBinding::Bindable(Rc::new(300 closure!(clone value, clone context_creator, clone params, |this, super_obj| {301 302 Ok(LazyVal::new_resolved(evaluate_method(303 context_creator.0(this, super_obj)?,304 params.clone(),305 value.clone(),306 )))307 }),308 )),309 location: value.1.clone(),310 },311 );312 }313 Member::BindStmt(_) => {}314 Member::AssertStmt(_) => {}315 }316 }317 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))318}319320pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {321 Ok(match object {322 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,323 ObjBody::ObjComp(obj) => {324 let future_this = FutureObjValue::new();325 let mut new_members = HashMap::new();326 for (k, v) in evaluate_comp(327 context.clone(),328 &|ctx| {329 let new_bindings = FutureNewBindings::new();330 let context_creator = context_creator!(331 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {332 Ok(context.extend_unbound(333 new_bindings.clone().unwrap(),334 context.dollar().clone().or_else(||this.clone()),335 None,336 super_obj337 )?)338 })339 );340 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();341 for (n, b) in obj342 .pre_locals343 .iter()344 .chain(obj.post_locals.iter())345 .map(|b| evaluate_binding(b, context_creator.clone()))346 {347 bindings.insert(n, b);348 }349 let bindings = new_bindings.fill(bindings);350 let ctx = ctx.extend_unbound(bindings, None, None, None)?;351 let key = evaluate(ctx.clone(), &obj.key)?;352 let value = LazyBinding::Bindable(Rc::new(353 closure!(clone ctx, clone obj.value, |this, _super_obj| {354 Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))355 }),356 ));357358 Ok((key, value))359 },360 &obj.compspecs,361 )?362 .unwrap()363 {364 match k {365 Val::Null => {}366 Val::Str(n) => {367 new_members.insert(368 n,369 ObjMember {370 add: false,371 visibility: Visibility::Normal,372 invoke: v,373 location: obj.value.1.clone(),374 },375 );376 }377 v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,378 }379 }380381 future_this.fill(ObjValue::new(None, Rc::new(new_members)))382 }383 })384}385386387388macro_rules! noinline {389 ($e:expr) => {390 (#[inline(never)]391 move || $e)()392 };393}394395pub fn evaluate_apply(396 context: Context,397 value: &LocExpr,398 args: &ArgsDesc,399 loc: &Option<ExprLocation>,400 tailstrict: bool,401) -> Result<Val> {402 let lazy = evaluate(context.clone(), value)?;403 let value = lazy.unwrap_if_lazy()?;404 Ok(match value {405 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {406 407 ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [408 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];409 ], {410 Ok(match x {411 Val::Str(n) => Val::Num(n.chars().count() as f64),412 Val::Arr(i) => Val::Num(i.len() as f64),413 Val::Obj(o) => Val::Num(414 o.fields_visibility()415 .into_iter()416 .filter(|(_k, v)| *v)417 .count() as f64,418 ),419 _ => unreachable!(),420 })421 }))?,422 423 ("std", "type") => parse_args!(context, "std.type", args, 1, [424 0, x, vec![];425 ], {426 Val::Str(x.value_type()?.name().into())427 }),428 429 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [430 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];431 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];432 ], {433 if sz < 0.0 {434 create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;435 }436 let mut out = Vec::with_capacity(sz as usize);437 for i in 0..sz as usize {438 out.push(func.evaluate_values(439 Context::new(),440 &[Val::Num(i as f64)]441 )?)442 }443 Ok(Val::Arr(Rc::new(out)))444 }))?,445 446 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [447 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];448 ], {449 assert!(450 str.chars().count() == 1,451 "std.codepoint should receive single char string"452 );453 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)454 }),455 456 ("std", "objectFieldsEx") => {457 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [458 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];459 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];460 ], {461 let mut out = obj.fields_visibility()462 .into_iter()463 .filter(|(_k, v)| *v || inc_hidden)464 .map(|(k, _v)|k)465 .collect::<Vec<_>>();466 out.sort();467 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))468 }))?469 }470 471 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [472 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];473 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];474 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];475 ], {476 Val::Bool(477 obj.fields_visibility()478 .into_iter()479 .filter(|(_k, v)| *v || inc_hidden)480 .any(|(k, _v)| *k == *f),481 )482 }),483 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [484 0, a, vec![];485 1, b, vec![];486 ], {487 Val::Bool(a == b)488 }),489 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [490 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];491 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];492 ], {493 Val::Num(a % b)494 }),495 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [496 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];497 ], {498 Val::Num(x.floor())499 }),500 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [501 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];502 1, rest, vec![];503 ], {504 eprint!("TRACE: ");505 if let Some(loc) = loc {506 with_state(|s|{507 let locs = s.map_source_locations(&loc.0, &[loc.1]);508 eprint!("{}:{} ", loc.0.display(), locs[0].line);509 });510 }511 eprintln!("{}", str);512 rest513 }),514 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [515 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];516 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];517 ], {518 Val::Num(x.powf(n))519 }),520 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [521 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];522 ], {523 with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(524 || create_error(crate::Error::UndefinedExternalVariable(x)),525 )?526 }),527 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [528 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];529 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];530 ], {531 Ok(Val::Arr(Rc::new(532 arr.iter()533 .cloned()534 .filter(|e| {535 func536 .evaluate_values(context.clone(), &[e.clone()])537 .unwrap()538 .try_cast_bool("filter predicate")539 .unwrap()540 })541 .collect(),542 )))543 }))?,544 ("std", "char") => parse_args!(context, "std.char", args, 1, [545 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];546 ], {547 let mut out = String::new();548 out.push(std::char::from_u32(n as u32).unwrap());549 Val::Str(out.into())550 }),551 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [552 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];553 ], {554 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))555 }),556 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [557 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];558 ], {559 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))560 }))?,561 562 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [563 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];564 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];565 ], {566 Ok(match sep {567 Val::Arr(joiner_items) => {568 let mut out = Vec::new();569570 let mut first = true;571 for item in arr.iter().cloned() {572 if let Val::Arr(items) = item.unwrap_if_lazy()? {573 if !first {574 out.reserve(joiner_items.len());575 out.extend(joiner_items.iter().cloned());576 }577 first = false;578 out.reserve(items.len());579 out.extend(items.iter().cloned());580 } else {581 create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;582 }583 }584585 Val::Arr(Rc::new(out))586 },587 Val::Str(sep) => {588 let mut out = String::new();589590 let mut first = true;591 for item in arr.iter().cloned() {592 if let Val::Str(item) = item.unwrap_if_lazy()? {593 if !first {594 out += &sep;595 }596 first = false;597 out += &item;598 } else {599 create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;600 }601 }602603 Val::Str(out.into())604 },605 _ => unreachable!()606 })607 }))?,608 609 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [610 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];611 ], {612 Val::Str(escape_string_json(&str_).into())613 }),614 615 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [616 0, value, vec![];617 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];618 ], {619 Val::Str(manifest_json_ex(&value, &indent)?.into())620 }),621 (ns, name) => {622 create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?623 }624 },625 Val::Func(f) => {626 let body = || f.evaluate(context, args, tailstrict);627 if tailstrict {628 body()?629 } else {630 push(loc, "function call", body)?631 }632 }633 v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,634 })635}636637pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {638 use Expr::*;639 let LocExpr(expr, loc) = expr;640 Ok(match &**expr {641 Literal(LiteralType::This) => Val::Obj(642 context643 .this()644 .clone()645 .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,646 ),647 Literal(LiteralType::Dollar) => Val::Obj(648 context649 .dollar()650 .clone()651 .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,652 ),653 Literal(LiteralType::True) => Val::Bool(true),654 Literal(LiteralType::False) => Val::Bool(false),655 Literal(LiteralType::Null) => Val::Null,656 Parened(e) => evaluate(context, e)?,657 Str(v) => Val::Str(v.clone()),658 Num(v) => Val::new_checked_num(*v)?,659 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,660 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,661 Var(name) => push(loc, "var", || {662 Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?)663 })?,664 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {665 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;666 context667 .super_obj()668 .clone()669 .expect("no super found")670 .get_raw(&name, &context.this().clone().expect("no this found"))?671 .expect("value not found")672 }673 Index(value, index) => {674 match (675 evaluate(context.clone(), value)?.unwrap_if_lazy()?,676 evaluate(context, index)?,677 ) {678 (Val::Obj(v), Val::Str(s)) => {679 if let Some(v) = v.get(s.clone())? {680 v.unwrap_if_lazy()?681 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {682 Val::Intristic(n, s)683 } else {684 create_error_result(crate::Error::NoSuchField(s))?685 }686 }687 (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(688 ValType::Obj,689 ValType::Str,690 n.value_type()?,691 ))?,692693 (Val::Arr(v), Val::Num(n)) => {694 if n.fract() > f64::EPSILON {695 create_error_result(crate::Error::FractionalIndex)?696 }697 v.get(n as usize)698 .ok_or_else(|| {699 create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))700 })?701 .clone()702 .unwrap_if_lazy()?703 }704 (Val::Arr(_), Val::Str(n)) => {705 create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?706 }707 (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(708 ValType::Arr,709 ValType::Num,710 n.value_type()?,711 ))?,712713 (Val::Str(s), Val::Num(n)) => Val::Str(714 s.chars()715 .skip(n as usize)716 .take(1)717 .collect::<String>()718 .into(),719 ),720 (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(721 ValType::Str,722 ValType::Num,723 n.value_type()?,724 ))?,725726 (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,727 }728 }729 LocalExpr(bindings, returned) => {730 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();731 let future_context = Context::new_future();732733 let context_creator = context_creator!(734 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))735 );736737 for (k, v) in bindings738 .iter()739 .map(|b| evaluate_binding(b, context_creator.clone()))740 {741 new_bindings.insert(k, v);742 }743744 let context = context745 .extend_unbound(new_bindings, None, None, None)?746 .into_future(future_context);747 evaluate(context, &returned.clone())?748 }749 Arr(items) => {750 let mut out = Vec::with_capacity(items.len());751 for item in items {752 out.push(Val::Lazy(lazy_val!(753 closure!(clone context, clone item, || {754 evaluate(context.clone(), &item)755 })756 )));757 }758 Val::Arr(Rc::new(out))759 }760 ArrComp(expr, compspecs) => Val::Arr(761 762 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),763 ),764 Obj(body) => Val::Obj(evaluate_object(context, body)?),765 ObjExtend(s, t) => evaluate_add_op(766 &evaluate(context.clone(), s)?,767 &Val::Obj(evaluate_object(context, t)?),768 )?,769 Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,770 Function(params, body) => evaluate_method(context, params.clone(), body.clone()),771 AssertExpr(AssertStmt(value, msg), returned) => {772 let assertion_result = push(&value.1, "assertion condition", || {773 evaluate(context.clone(), &value)?774 .try_cast_bool("assertion condition should be boolean")775 })?;776 if assertion_result {777 evaluate(context, returned)?778 } else if let Some(msg) = msg {779 create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?780 } else {781 create_error_result(crate::Error::AssertionFailed(Val::Null))?782 }783 }784 Error(e) => create_error_result(crate::Error::RuntimeError(785 evaluate(context, e)?.try_cast_str("error text should be string")?,786 ))?,787 IfElse {788 cond,789 cond_then,790 cond_else,791 } => {792 if evaluate(context.clone(), &cond.0)?793 .try_cast_bool("if condition should be boolean")?794 {795 evaluate(context, cond_then)?796 } else {797 match cond_else {798 Some(v) => evaluate(context, v)?,799 None => Val::Null,800 }801 }802 }803 Import(path) => {804 let mut tmp = loc805 .clone()806 .expect("imports can't be used without loc_data")807 .0;808 let import_location = Rc::make_mut(&mut tmp);809 import_location.pop();810 with_state(|s| s.import_file(&import_location, path))?811 }812 ImportStr(path) => {813 let mut tmp = loc814 .clone()815 .expect("imports can't be used without loc_data")816 .0;817 let import_location = Rc::make_mut(&mut tmp);818 import_location.pop();819 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)820 }821 Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),822 })823}