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(evaluate(271 context_creator.0(this, super_obj)?,272 &value,273 )?))274 }),275 )),276 location: value.1.clone(),277 },278 );279 }280 Member::Field(FieldMember {281 name,282 params: Some(params),283 value,284 ..285 }) => {286 let name = evaluate_field_name(context.clone(), &name)?;287 if name.is_none() {288 continue;289 }290 let name = name.unwrap();291 new_members.insert(292 name,293 ObjMember {294 add: false,295 visibility: Visibility::Hidden,296 invoke: LazyBinding::Bindable(Rc::new(297 closure!(clone value, clone context_creator, clone params, |this, super_obj| {298 299 Ok(LazyVal::new_resolved(evaluate_method(300 context_creator.0(this, super_obj)?,301 params.clone(),302 value.clone(),303 )))304 }),305 )),306 location: value.1.clone(),307 },308 );309 }310 Member::BindStmt(_) => {}311 Member::AssertStmt(_) => {}312 }313 }314 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))315}316317pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {318 Ok(match object {319 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,320 ObjBody::ObjComp(obj) => {321 let future_this = FutureObjValue::new();322 let mut new_members = HashMap::new();323 for (k, v) in evaluate_comp(324 context.clone(),325 &|ctx| {326 let new_bindings = FutureNewBindings::new();327 let context_creator = context_creator!(328 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {329 Ok(context.extend_unbound(330 new_bindings.clone().unwrap(),331 context.dollar().clone().or_else(||this.clone()),332 None,333 super_obj334 )?)335 })336 );337 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();338 for (n, b) in obj339 .pre_locals340 .iter()341 .chain(obj.post_locals.iter())342 .map(|b| evaluate_binding(b, context_creator.clone()))343 {344 bindings.insert(n, b);345 }346 let bindings = new_bindings.fill(bindings);347 let ctx = ctx.extend_unbound(bindings, None, None, None)?;348 let key = evaluate(ctx.clone(), &obj.key)?;349 let value = LazyBinding::Bindable(Rc::new(350 closure!(clone ctx, clone obj.value, |this, _super_obj| {351 Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))352 }),353 ));354355 Ok((key, value))356 },357 &obj.compspecs,358 )?359 .unwrap()360 {361 match k {362 Val::Null => {}363 Val::Str(n) => {364 new_members.insert(365 n,366 ObjMember {367 add: false,368 visibility: Visibility::Normal,369 invoke: v,370 location: obj.value.1.clone(),371 },372 );373 }374 v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,375 }376 }377378 future_this.fill(ObjValue::new(None, Rc::new(new_members)))379 }380 })381}382383384385macro_rules! noinline {386 ($e:expr) => {387 (#[inline(never)]388 move || $e)()389 };390}391392pub fn evaluate_apply(393 context: Context,394 value: &LocExpr,395 args: &ArgsDesc,396 loc: &Option<ExprLocation>,397 tailstrict: bool,398) -> Result<Val> {399 let lazy = evaluate(context.clone(), value)?;400 let value = lazy.unwrap_if_lazy()?;401 Ok(match value {402 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {403 404 ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [405 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];406 ], {407 Ok(match x {408 Val::Str(n) => Val::Num(n.chars().count() as f64),409 Val::Arr(i) => Val::Num(i.len() as f64),410 Val::Obj(o) => Val::Num(411 o.fields_visibility()412 .into_iter()413 .filter(|(_k, v)| *v)414 .count() as f64,415 ),416 _ => unreachable!(),417 })418 }))?,419 420 ("std", "type") => parse_args!(context, "std.type", args, 1, [421 0, x, vec![];422 ], {423 Val::Str(x.value_type()?.name().into())424 }),425 426 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [427 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];428 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];429 ], {430 if sz < 0.0 {431 create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;432 }433 let mut out = Vec::with_capacity(sz as usize);434 for i in 0..sz as usize {435 out.push(func.evaluate_values(436 Context::new(),437 &[Val::Num(i as f64)]438 )?)439 }440 Ok(Val::Arr(Rc::new(out)))441 }))?,442 443 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [444 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];445 ], {446 assert!(447 str.chars().count() == 1,448 "std.codepoint should receive single char string"449 );450 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)451 }),452 453 ("std", "objectFieldsEx") => {454 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [455 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];456 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];457 ], {458 let mut out = obj.fields_visibility()459 .into_iter()460 .filter(|(_k, v)| *v || inc_hidden)461 .map(|(k, _v)|k)462 .collect::<Vec<_>>();463 out.sort();464 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))465 }))?466 }467 468 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [469 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];470 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];471 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];472 ], {473 Val::Bool(474 obj.fields_visibility()475 .into_iter()476 .filter(|(_k, v)| *v || inc_hidden)477 .any(|(k, _v)| *k == *f),478 )479 }),480 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [481 0, a, vec![];482 1, b, vec![];483 ], {484 Val::Bool(primitive_equals(&a, &b)?)485 }),486 487 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [488 0, a, vec![];489 1, b, vec![];490 ], {491 Val::Bool(equals(&a, &b)?)492 }),493 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [494 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];495 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];496 ], {497 Val::Num(a % b)498 }),499 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [500 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];501 ], {502 Val::Num(x.floor())503 }),504 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [505 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];506 1, rest, vec![];507 ], {508 eprint!("TRACE: ");509 if let Some(loc) = loc {510 with_state(|s|{511 let locs = s.map_source_locations(&loc.0, &[loc.1]);512 eprint!("{}:{} ", loc.0.display(), locs[0].line);513 });514 }515 eprintln!("{}", str);516 rest517 }),518 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [519 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];520 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];521 ], {522 Val::Num(x.powf(n))523 }),524 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [525 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];526 ], {527 with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(528 || create_error(crate::Error::UndefinedExternalVariable(x)),529 )?530 }),531 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [532 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];533 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];534 ], {535 Ok(Val::Arr(Rc::new(536 arr.iter()537 .cloned()538 .filter(|e| {539 func540 .evaluate_values(context.clone(), &[e.clone()])541 .unwrap()542 .try_cast_bool("filter predicate")543 .unwrap()544 })545 .collect(),546 )))547 }))?,548 ("std", "char") => parse_args!(context, "std.char", args, 1, [549 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];550 ], {551 let mut out = String::new();552 out.push(std::char::from_u32(n as u32).unwrap());553 Val::Str(out.into())554 }),555 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [556 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];557 ], {558 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))559 }),560 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [561 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];562 ], {563 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))564 }))?,565 566 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [567 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];568 ], {569 Val::Str(match input {570 Val::Str(s) => {571 base64::encode(s.bytes().collect::<Vec<_>>()).into()572 },573 Val::Arr(a) => {574 base64::encode(a.iter().map(|v| {575 Ok(v.clone().try_cast_num("base64 array")? as u8)576 }).collect::<Result<Vec<_>>>()?).into()577 },578 _ => unreachable!()579 })580 }),581 582 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [583 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];584 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];585 ], {586 Ok(match sep {587 Val::Arr(joiner_items) => {588 let mut out = Vec::new();589590 let mut first = true;591 for item in arr.iter().cloned() {592 if let Val::Arr(items) = item.unwrap_if_lazy()? {593 if !first {594 out.reserve(joiner_items.len());595 out.extend(joiner_items.iter().cloned());596 }597 first = false;598 out.reserve(items.len());599 out.extend(items.iter().cloned());600 } else {601 create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;602 }603 }604605 Val::Arr(Rc::new(out))606 },607 Val::Str(sep) => {608 let mut out = String::new();609610 let mut first = true;611 for item in arr.iter().cloned() {612 if let Val::Str(item) = item.unwrap_if_lazy()? {613 if !first {614 out += &sep;615 }616 first = false;617 out += &item;618 } else {619 create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;620 }621 }622623 Val::Str(out.into())624 },625 _ => unreachable!()626 })627 }))?,628 629 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [630 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];631 ], {632 Val::Str(escape_string_json(&str_).into())633 }),634 635 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [636 0, value, vec![];637 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];638 ], {639 Val::Str(manifest_json_ex(&value, &indent)?.into())640 }),641 (ns, name) => {642 create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?643 }644 },645 Val::Func(f) => {646 let body = || f.evaluate(context, args, tailstrict);647 if tailstrict {648 body()?649 } else {650 push(loc, "function call", body)?651 }652 }653 v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,654 })655}656657pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {658 use Expr::*;659 let LocExpr(expr, loc) = expr;660 Ok(match &**expr {661 Literal(LiteralType::This) => Val::Obj(662 context663 .this()664 .clone()665 .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,666 ),667 Literal(LiteralType::Dollar) => Val::Obj(668 context669 .dollar()670 .clone()671 .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,672 ),673 Literal(LiteralType::True) => Val::Bool(true),674 Literal(LiteralType::False) => Val::Bool(false),675 Literal(LiteralType::Null) => Val::Null,676 Parened(e) => evaluate(context, e)?,677 Str(v) => Val::Str(v.clone()),678 Num(v) => Val::new_checked_num(*v)?,679 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,680 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,681 Var(name) => push(682 loc,683 || "var".to_owned(),684 || Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),685 )?,686 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {687 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;688 context689 .super_obj()690 .clone()691 .expect("no super found")692 .get_raw(&name, &context.this().clone().expect("no this found"))?693 .expect("value not found")694 }695 Index(value, index) => {696 match (697 evaluate(context.clone(), value)?.unwrap_if_lazy()?,698 evaluate(context, index)?,699 ) {700 (Val::Obj(v), Val::Str(s)) => {701 if let Some(v) = v.get(s.clone())? {702 v.unwrap_if_lazy()?703 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {704 Val::Intristic(n, s)705 } else {706 create_error_result(crate::Error::NoSuchField(s))?707 }708 }709 (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(710 ValType::Obj,711 ValType::Str,712 n.value_type()?,713 ))?,714715 (Val::Arr(v), Val::Num(n)) => {716 if n.fract() > f64::EPSILON {717 create_error_result(crate::Error::FractionalIndex)?718 }719 v.get(n as usize)720 .ok_or_else(|| {721 create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))722 })?723 .clone()724 .unwrap_if_lazy()?725 }726 (Val::Arr(_), Val::Str(n)) => {727 create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?728 }729 (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(730 ValType::Arr,731 ValType::Num,732 n.value_type()?,733 ))?,734735 (Val::Str(s), Val::Num(n)) => Val::Str(736 s.chars()737 .skip(n as usize)738 .take(1)739 .collect::<String>()740 .into(),741 ),742 (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(743 ValType::Str,744 ValType::Num,745 n.value_type()?,746 ))?,747748 (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,749 }750 }751 LocalExpr(bindings, returned) => {752 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();753 let future_context = Context::new_future();754755 let context_creator = context_creator!(756 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))757 );758759 for (k, v) in bindings760 .iter()761 .map(|b| evaluate_binding(b, context_creator.clone()))762 {763 new_bindings.insert(k, v);764 }765766 let context = context767 .extend_unbound(new_bindings, None, None, None)?768 .into_future(future_context);769 evaluate(context, &returned.clone())?770 }771 Arr(items) => {772 let mut out = Vec::with_capacity(items.len());773 for item in items {774 out.push(Val::Lazy(lazy_val!(775 closure!(clone context, clone item, || {776 evaluate(context.clone(), &item)777 })778 )));779 }780 Val::Arr(Rc::new(out))781 }782 ArrComp(expr, compspecs) => Val::Arr(783 784 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),785 ),786 Obj(body) => Val::Obj(evaluate_object(context, body)?),787 ObjExtend(s, t) => evaluate_add_op(788 &evaluate(context.clone(), s)?,789 &Val::Obj(evaluate_object(context, t)?),790 )?,791 Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,792 Function(params, body) => evaluate_method(context, params.clone(), body.clone()),793 AssertExpr(AssertStmt(value, msg), returned) => {794 let assertion_result = push(795 &value.1,796 || "assertion condition".to_owned(),797 || {798 evaluate(context.clone(), &value)?799 .try_cast_bool("assertion condition should be boolean")800 },801 )?;802 if assertion_result {803 evaluate(context, returned)?804 } else if let Some(msg) = msg {805 create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?806 } else {807 create_error_result(crate::Error::AssertionFailed(Val::Null))?808 }809 }810 Error(e) => push(811 &loc,812 || "error statement".to_owned(),813 || {814 create_error_result(crate::Error::RuntimeError(815 evaluate(context, e)?.try_cast_str("error text should be string")?,816 ))?817 },818 )?,819 IfElse {820 cond,821 cond_then,822 cond_else,823 } => {824 if evaluate(context.clone(), &cond.0)?825 .try_cast_bool("if condition should be boolean")?826 {827 evaluate(context, cond_then)?828 } else {829 match cond_else {830 Some(v) => evaluate(context, v)?,831 None => Val::Null,832 }833 }834 }835 Import(path) => {836 let mut tmp = loc837 .clone()838 .expect("imports can't be used without loc_data")839 .0;840 let import_location = Rc::make_mut(&mut tmp);841 import_location.pop();842 with_state(|s| s.import_file(&import_location, path))?843 }844 ImportStr(path) => {845 let mut tmp = loc846 .clone()847 .expect("imports can't be used without loc_data")848 .0;849 let import_location = Rc::make_mut(&mut tmp);850 import_location.pop();851 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)852 }853 Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),854 })855}