difftreelog
fix(evaluator) use exceptions instead of panic in functions
in: master
1 file changed
crates/jsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth1use crate::{2 context_creator, create_error, escape_string_json, future_wrapper, lazy_val, manifest_json_ex,3 parse_args, push, with_state, Context, ContextCreator, Error, FuncDesc, LazyBinding, LazyVal,4 ObjMember, ObjValue, Result, Val, ValType,5};6use closure::closure;7use jsonnet_parser::{8 el, Arg, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember,9 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,10 Visibility,11};12use std::{13 collections::{BTreeMap, HashMap},14 rc::Rc,15};1617pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {18 let b = b.clone();19 if let Some(params) = &b.params {20 let params = params.clone();21 (22 b.name.clone(),23 LazyBinding::Bindable(Rc::new(move |this, super_obj| {24 Ok(lazy_val!(25 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(26 context_creator.0(this.clone(), super_obj.clone())?,27 params.clone(),28 b.value.clone(),29 )))30 ))31 })),32 )33 } else {34 (35 b.name.clone(),36 LazyBinding::Bindable(Rc::new(move |this, super_obj| {37 Ok(lazy_val!(closure!(clone context_creator, clone b, ||38 push(&b.value.1, "thunk", ||{39 evaluate(40 context_creator.0(this.clone(), super_obj.clone())?,41 &b.value42 )43 })44 )))45 })),46 )47 }48}4950pub fn evaluate_method(ctx: Context, params: ParamsDesc, body: LocExpr) -> Val {51 Val::Func(FuncDesc { ctx, params, body })52}5354pub fn evaluate_field_name(55 context: Context,56 field_name: &jsonnet_parser::FieldName,57) -> Result<Option<Rc<str>>> {58 Ok(match field_name {59 jsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),60 jsonnet_parser::FieldName::Dyn(expr) => {61 let lazy = evaluate(context, expr)?;62 let value = lazy.unwrap_if_lazy()?;63 if matches!(value, Val::Null) {64 None65 } else {66 Some(value.try_cast_str("dynamic field name")?)67 }68 }69 })70}7172pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {73 Ok(match (op, b) {74 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,75 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),76 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),77 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),78 (op, o) => panic!("unary op not implemented: {:?} {:?}", op, o),79 })80}8182pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {83 Ok(match (a, b) {84 (Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),8586 // Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)87 (Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),88 (Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),8990 (Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),91 (o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),9293 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),94 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),95 (Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),96 _ => panic!("can't add: {:?} and {:?}", a, b),97 })98}99100pub fn evaluate_binary_op_special(101 context: Context,102 a: &LocExpr,103 op: BinaryOpType,104 b: &LocExpr,105) -> Result<Val> {106 Ok(107 match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {108 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),109 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),110 (a, op, eb) => {111 evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?112 }113 },114 )115}116117pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {118 Ok(match (a, op, b) {119 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,120121 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),122123 // Bool X Bool124 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),125 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),126127 // Str X Str128 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),129 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),130 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),131 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),132133 // Num X Num134 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Num(v1 * v2),135 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {136 if *v2 <= f64::EPSILON {137 create_error(crate::Error::DivisionByZero)?138 }139 Val::Num(v1 / v2)140 }141142 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::Num(v1 - v2),143144 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),145 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),146 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),147 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),148149 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {150 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)151 }152 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {153 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)154 }155 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {156 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)157 }158 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {159 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)160 }161 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {162 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)163 }164165 _ => panic!("no rules for binary operation: {:?} {:?} {:?}", a, op, b),166 })167}168169future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);170future_wrapper!(ObjValue, FutureObjValue);171172pub fn evaluate_comp<T>(173 context: Context,174 value: &impl Fn(Context) -> Result<T>,175 specs: &[CompSpec],176) -> Result<Option<Vec<T>>> {177 Ok(match specs.get(0) {178 None => Some(vec![value(context)?]),179 Some(CompSpec::IfSpec(IfSpecData(cond))) => {180 if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {181 evaluate_comp(context, value, &specs[1..])?182 } else {183 None184 }185 }186 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {187 match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {188 Val::Arr(list) => {189 let mut out = Vec::new();190 for item in list.iter() {191 let item = item.unwrap_if_lazy()?;192 out.push(evaluate_comp(193 context.with_var(var.clone(), item.clone())?,194 value,195 &specs[1..],196 )?);197 }198 Some(out.into_iter().flatten().flatten().collect())199 }200 _ => panic!("for expression evaluated to non-iterable value"),201 }202 }203 })204}205206pub fn evaluate_member_list_object(context: Context, members: &Vec<Member>) -> Result<ObjValue> {207 let new_bindings = FutureNewBindings::new();208 let future_this = FutureObjValue::new();209 let context_creator = context_creator!(210 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {211 Ok(context.extend_unbound(212 new_bindings.clone().unwrap(),213 context.dollar().clone().or_else(||this.clone()),214 Some(this.unwrap()),215 super_obj216 )?)217 })218 );219 {220 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();221 for (n, b) in members222 .iter()223 .filter_map(|m| match m {224 Member::BindStmt(b) => Some(b.clone()),225 _ => None,226 })227 .map(|b| evaluate_binding(&b, context_creator.clone()))228 {229 bindings.insert(n, b);230 }231 new_bindings.fill(bindings);232 }233234 let mut new_members = BTreeMap::new();235 for member in members.iter() {236 match member {237 Member::Field(FieldMember {238 name,239 plus,240 params: None,241 visibility,242 value,243 }) => {244 let name = evaluate_field_name(context.clone(), &name)?;245 if name.is_none() {246 continue;247 }248 let name = name.unwrap();249 new_members.insert(250 name.clone(),251 ObjMember {252 add: *plus,253 visibility: *visibility,254 invoke: LazyBinding::Bindable(Rc::new(255 closure!(clone name, clone value, clone context_creator, |this, super_obj| {256 Ok(LazyVal::new_resolved(push(&value.1, "object field", ||{257 let context = context_creator.0(this, super_obj)?;258 evaluate(259 context,260 &value,261 )262 })?))263 }),264 )),265 },266 );267 }268 Member::Field(FieldMember {269 name,270 params: Some(params),271 value,272 ..273 }) => {274 let name = evaluate_field_name(context.clone(), &name)?;275 if name.is_none() {276 continue;277 }278 let name = name.unwrap();279 new_members.insert(280 name,281 ObjMember {282 add: false,283 visibility: Visibility::Hidden,284 invoke: LazyBinding::Bindable(Rc::new(285 closure!(clone value, clone context_creator, clone params, |this, super_obj| {286 // TODO: Assert287 Ok(LazyVal::new_resolved(evaluate_method(288 context_creator.0(this, super_obj)?,289 params.clone(),290 value.clone(),291 )))292 }),293 )),294 },295 );296 }297 Member::BindStmt(_) => {}298 Member::AssertStmt(_) => {}299 }300 }301 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))302}303304pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {305 Ok(match object {306 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,307 ObjBody::ObjComp(obj) => {308 let future_this = FutureObjValue::new();309 let mut new_members = BTreeMap::new();310 for (k, v) in evaluate_comp(311 context.clone(),312 &|ctx| {313 let new_bindings = FutureNewBindings::new();314 let context_creator = context_creator!(315 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {316 Ok(context.extend_unbound(317 new_bindings.clone().unwrap(),318 context.dollar().clone().or_else(||this.clone()),319 None,320 super_obj321 )?)322 })323 );324 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();325 for (n, b) in obj326 .pre_locals327 .iter()328 .chain(obj.post_locals.iter())329 .map(|b| evaluate_binding(b, context_creator.clone()))330 {331 bindings.insert(n, b);332 }333 let bindings = new_bindings.fill(bindings);334 let ctx = ctx.extend_unbound(bindings, None, None, None)?;335 let key = evaluate(ctx.clone(), &obj.key)?;336 let value = LazyBinding::Bindable(Rc::new(337 closure!(clone ctx, clone obj.value, |this, _super_obj| {338 Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))339 }),340 ));341342 Ok((key, value))343 },344 &obj.compspecs,345 )?346 .unwrap()347 {348 match k {349 Val::Null => {}350 Val::Str(n) => {351 new_members.insert(352 n,353 ObjMember {354 add: false,355 visibility: Visibility::Normal,356 invoke: v,357 },358 );359 }360 v => create_error(Error::FieldMustBeStringGot(v.value_type()?))?,361 }362 }363364 future_this.fill(ObjValue::new(None, Rc::new(new_members)))365 }366 })367}368369pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {370 use Expr::*;371 let LocExpr(expr, loc) = expr;372 Ok(match &**expr {373 Literal(LiteralType::This) => Val::Obj(374 context375 .this()376 .clone()377 .unwrap_or_else(|| panic!("this not found")),378 ),379 Literal(LiteralType::Dollar) => Val::Obj(380 context381 .dollar()382 .clone()383 .unwrap_or_else(|| panic!("dollar not found")),384 ),385 Literal(LiteralType::True) => Val::Bool(true),386 Literal(LiteralType::False) => Val::Bool(false),387 Literal(LiteralType::Null) => Val::Null,388 Parened(e) => evaluate(context, e)?,389 Str(v) => Val::Str(v.clone()),390 Num(v) => Val::Num(*v),391 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,392 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,393 Var(name) => push(loc, "var", || {394 Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?)395 })?,396 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {397 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;398 context399 .super_obj()400 .clone()401 .expect("no super found")402 .get_raw(&name, &context.this().clone().expect("no this found"))?403 .expect("value not found")404 }405 Index(value, index) => {406 match (407 evaluate(context.clone(), value)?.unwrap_if_lazy()?,408 evaluate(context, index)?,409 ) {410 (Val::Obj(v), Val::Str(s)) => {411 if let Some(v) = v.get(s.clone())? {412 v.unwrap_if_lazy()?413 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {414 Val::Intristic(n, s)415 } else {416 create_error(crate::Error::NoSuchField(s))?417 }418 }419 (Val::Obj(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(420 ValType::Obj,421 ValType::Str,422 n.value_type()?,423 ))?,424425 (Val::Arr(v), Val::Num(n)) => {426 if n.fract() > f64::EPSILON {427 create_error(crate::Error::FractionalIndex)?428 }429 v.get(n as usize)430 .unwrap_or_else(|| panic!("out of bounds"))431 .clone()432 .unwrap_if_lazy()?433 }434 (Val::Arr(_), Val::Str(n)) => {435 create_error(crate::Error::AttemptedIndexAnArrayWithString(n))?436 }437 (Val::Arr(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(438 ValType::Arr,439 ValType::Num,440 n.value_type()?,441 ))?,442443 (Val::Str(s), Val::Num(n)) => Val::Str(444 s.chars()445 .skip(n as usize)446 .take(1)447 .collect::<String>()448 .into(),449 ),450 (Val::Str(_), n) => create_error(crate::Error::ValueIndexMustBeTypeGot(451 ValType::Str,452 ValType::Num,453 n.value_type()?,454 ))?,455456 (v, _) => create_error(crate::Error::CantIndexInto(v.value_type()?))?,457 }458 }459 LocalExpr(bindings, returned) => {460 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();461 let future_context = Context::new_future();462463 let context_creator = context_creator!(464 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))465 );466467 for (k, v) in bindings468 .iter()469 .map(|b| evaluate_binding(b, context_creator.clone()))470 {471 new_bindings.insert(k, v);472 }473474 let context = context475 .extend_unbound(new_bindings, None, None, None)?476 .into_future(future_context);477 evaluate(context, &returned.clone())?478 }479 Arr(items) => {480 let mut out = Vec::with_capacity(items.len());481 for item in items {482 out.push(Val::Lazy(lazy_val!(483 closure!(clone context, clone item, || {484 evaluate(context.clone(), &item)485 })486 )));487 }488 Val::Arr(Rc::new(out))489 }490 ArrComp(expr, compspecs) => Val::Arr(491 // First compspec should be forspec, so no "None" possible here492 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),493 ),494 Obj(body) => Val::Obj(evaluate_object(context, body)?),495 ObjExtend(s, t) => evaluate_add_op(496 &evaluate(context.clone(), s)?,497 &Val::Obj(evaluate_object(context, t)?),498 )?,499 Apply(value, args, tailstrict) => {500 let lazy = evaluate(context.clone(), value)?;501 let value = lazy.unwrap_if_lazy()?;502 match value {503 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {504 // arr/string/function505 ("std", "length") => parse_args!(context, "std.length", args, 1, [506 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];507 ], {508 match x {509 Val::Str(n) => Val::Num(n.chars().count() as f64),510 Val::Arr(i) => Val::Num(i.len() as f64),511 Val::Obj(o) => Val::Num(512 o.fields_visibility()513 .into_iter()514 .filter(|(_k, v)| *v)515 .count() as f64,516 ),517 _ => unreachable!(),518 }519 }),520 // any521 ("std", "type") => parse_args!(context, "std.type", args, 1, [522 0, x, vec![];523 ], {524 Val::Str(x.value_type()?.name().into())525 }),526 // length, idx=>any527 ("std", "makeArray") => parse_args!(context, "std.makeArray", args, 2, [528 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];529 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];530 ], {531 assert!(sz >= 0.0);532 let mut out = Vec::with_capacity(sz as usize);533 for i in 0..sz as usize {534 out.push(func.evaluate_values(535 Context::new(),536 &[Val::Num(i as f64)]537 )?)538 }539 Val::Arr(Rc::new(out))540 }),541 // string542 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [543 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];544 ], {545 assert!(546 str.chars().count() == 1,547 "std.codepoint should receive single char string"548 );549 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)550 }),551 // object, includeHidden552 ("std", "objectFieldsEx") => {553 parse_args!(context, "std.objectFieldsEx",args, 2, [554 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];555 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];556 ], {557 Val::Arr(Rc::new(558 obj.fields_visibility()559 .into_iter()560 .filter(|(_k, v)| *v || inc_hidden)561 .map(|(k, _v)| Val::Str(k))562 .collect(),563 ))564 })565 }566 // object, field, includeHidden567 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [568 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];569 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];570 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];571 ], {572 Val::Bool(573 obj.fields_visibility()574 .into_iter()575 .filter(|(_k, v)| *v || inc_hidden)576 .any(|(k, _v)| *k == *f),577 )578 }),579 ("std", "primitiveEquals") => {580 parse_args!(context, "std.primitiveEquals", args, 2, [581 0, a, vec![];582 1, b, vec![];583 ], {584 Val::Bool(a == b)585 })586 }587 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [588 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];589 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];590 ], {591 Val::Num(a % b)592 }),593 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [594 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];595 ], {596 Val::Num(x.floor())597 }),598 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [599 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];600 1, rest, vec![];601 ], {602 // TODO: Line numbers as in original jsonnet603 println!("TRACE: {}", str);604 rest605 }),606 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [607 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];608 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];609 ], {610 Val::Num(x.powf(n))611 }),612 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [613 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];614 ], {615 with_state(|s| s.0.ext_vars.borrow().get(&x).cloned()).ok_or_else(616 || {617 create_error::<()>(crate::Error::UndefinedExternalVariable(x))618 .err()619 .unwrap()620 },621 )?622 }),623 ("std", "filter") => parse_args!(context, "std.filter", args, 2, [624 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];625 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];626 ], {627 Val::Arr(Rc::new(628 arr.iter()629 .cloned()630 .filter(|e| {631 func632 .evaluate_values(context.clone(), &[e.clone()])633 .unwrap()634 .try_cast_bool("filter predicate")635 .unwrap()636 })637 .collect(),638 ))639 }),640 ("std", "char") => parse_args!(context, "std.char", args, 1, [641 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];642 ], {643 let mut out = String::new();644 out.push(std::char::from_u32(n as u32).unwrap());645 Val::Str(out.into())646 }),647 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [648 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];649 ], {650 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))651 }),652 ("std", "md5") => parse_args!(context, "std.md5", args, 1, [653 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];654 ], {655 Val::Str(format!("{:x}", md5::compute(str.as_bytes())).into())656 }),657 // faster658 ("std", "join") => parse_args!(context, "std.join", args, 2, [659 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];660 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];661 ], {662 match sep {663 Val::Arr(joiner_items) => {664 let mut out = Vec::new();665666 let mut first = true;667 for item in arr.iter().cloned() {668 if let Val::Arr(items) = item.unwrap_if_lazy()? {669 if !first {670 out.reserve(joiner_items.len());671 out.extend(joiner_items.iter().cloned());672 }673 first = false;674 out.reserve(items.len());675 out.extend(items.iter().cloned());676 } else {677 panic!("all array items should be arrays")678 }679 }680681 Val::Arr(Rc::new(out))682 },683 Val::Str(sep) => {684 let mut out = String::new();685686 let mut first = true;687 for item in arr.iter().cloned() {688 if let Val::Str(item) = item.unwrap_if_lazy()? {689 if !first {690 out += &sep;691 }692 first = false;693 out += &item;694 } else {695 panic!("all array items should be strings")696 }697 }698699 Val::Str(out.into())700 },701 _ => unreachable!()702 }703 }),704 // Faster705 ("std", "escapeStringJson") => {706 parse_args!(context, "std.escapeStringJson", args, 1, [707 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];708 ], {709 Val::Str(escape_string_json(&str_).into())710 })711 }712 // Faster713 ("std", "manifestJsonEx") => {714 parse_args!(context, "std.manifestJsonEx", args, 2, [715 0, value, vec![];716 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];717 ], {718 Val::Str(manifest_json_ex(&value, &indent)?.into())719 })720 }721 (ns, name) => panic!("Intristic not found: {}.{}", ns, name),722 },723 Val::Func(f) => {724 let body = || f.evaluate(context, args, *tailstrict);725 if *tailstrict {726 body()?727 } else {728 push(loc, "function call", body)?729 }730 }731 _ => panic!("{:?} is not a function", value),732 }733 }734 Function(params, body) => evaluate_method(context, params.clone(), body.clone()),735 AssertExpr(AssertStmt(value, msg), returned) => {736 let assertion_result = push(&value.1, "assertion condition", || {737 evaluate(context.clone(), &value)?738 .try_cast_bool("assertion condition should be boolean")739 })?;740 if assertion_result {741 evaluate(context, returned)?742 } else if let Some(msg) = msg {743 panic!(744 "assertion failed ({:?}): {}",745 value,746 evaluate(context, msg)?.try_cast_str("assertion message should be string")?747 );748 } else {749 panic!("assertion failed ({:?}): no message", value);750 }751 }752 Error(e) => create_error(crate::Error::RuntimeError(753 evaluate(context, e)?.try_cast_str("error text should be string")?,754 ))?,755 IfElse {756 cond,757 cond_then,758 cond_else,759 } => {760 if evaluate(context.clone(), &cond.0)?761 .try_cast_bool("if condition should be boolean")?762 {763 evaluate(context, cond_then)?764 } else {765 match cond_else {766 Some(v) => evaluate(context, v)?,767 None => Val::Null,768 }769 }770 }771 Import(path) => {772 let mut tmp = loc773 .clone()774 .expect("imports can't be used without loc_data")775 .0;776 let import_location = Rc::make_mut(&mut tmp);777 import_location.pop();778 with_state(|s| s.import_file(&import_location, path))?779 }780 ImportStr(path) => {781 let mut tmp = loc782 .clone()783 .expect("imports can't be used without loc_data")784 .0;785 let import_location = Rc::make_mut(&mut tmp);786 import_location.pop();787 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)788 }789 Literal(LiteralType::Super) => return create_error(crate::error::Error::StandaloneSuper),790 })791}