difftreelog
perf switch to external storage for object comp
in: master
1 file changed
crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth1use crate::{2 error::Error::*, lazy_val, push, throw, with_state, Context, ContextCreator, FuncDesc, FuncVal,3 FutureWrapper, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,4 equals,5};6use closure::closure;7use jrsonnet_interner::IStr;8use jrsonnet_parser::{9 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,10 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,11 Visibility,12};13use jrsonnet_types::ValType;14use rustc_hash::{FxHashMap, FxHasher};15use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};1617pub fn evaluate_binding_in_future(18 b: &BindSpec,19 context_creator: FutureWrapper<Context>,20) -> LazyVal {21 let b = b.clone();22 if let Some(params) = &b.params {23 let params = params.clone();24 LazyVal::new(Box::new(move || {25 Ok(evaluate_method(26 context_creator.unwrap(),27 b.name.clone(),28 params.clone(),29 b.value.clone(),30 ))31 }))32 } else {33 LazyVal::new(Box::new(move || {34 evaluate_named(context_creator.unwrap(), &b.value, b.name.clone())35 }))36 }37}3839pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {40 let b = b.clone();41 if let Some(params) = &b.params {42 let params = params.clone();43 (44 b.name.clone(),45 LazyBinding::Bindable(Rc::new(move |this, super_obj| {46 Ok(lazy_val!(47 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(48 context_creator.create(this.clone(), super_obj.clone())?,49 b.name.clone(),50 params.clone(),51 b.value.clone(),52 )))53 ))54 })),55 )56 } else {57 (58 b.name.clone(),59 LazyBinding::Bindable(Rc::new(move |this, super_obj| {60 Ok(lazy_val!(closure!(clone context_creator, clone b, ||61 evaluate_named(62 context_creator.create(this.clone(), super_obj.clone())?,63 &b.value,64 b.name.clone()65 )66 )))67 })),68 )69 }70}7172pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {73 Val::Func(Rc::new(FuncVal::Normal(FuncDesc {74 name,75 ctx,76 params,77 body,78 })))79}8081pub fn evaluate_field_name(82 context: Context,83 field_name: &jrsonnet_parser::FieldName,84) -> Result<Option<IStr>> {85 Ok(match field_name {86 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),87 jrsonnet_parser::FieldName::Dyn(expr) => {88 let value = evaluate(context, expr)?;89 if matches!(value, Val::Null) {90 None91 } else {92 Some(value.try_cast_str("dynamic field name")?)93 }94 }95 })96}9798pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {99 Ok(match (op, b) {100 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),101 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),102 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),103 (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),104 })105}106107pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {108 Ok(match (a, b) {109 (Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),110111 // Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)112 (Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),113 (Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),114115 (Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().to_string()?).into()),116 (o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),117118 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.extend_from(v1.clone())),119 (Val::Arr(a), Val::Arr(b)) => {120 let mut out = Vec::with_capacity(a.len() + b.len());121 out.extend(a.iter_lazy());122 out.extend(b.iter_lazy());123 Val::Arr(out.into())124 }125 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,126 _ => throw!(BinaryOperatorDoesNotOperateOnValues(127 BinaryOpType::Add,128 a.value_type(),129 b.value_type(),130 )),131 })132}133134pub fn evaluate_binary_op_special(135 context: Context,136 a: &LocExpr,137 op: BinaryOpType,138 b: &LocExpr,139) -> Result<Val> {140 Ok(match (evaluate(context.clone(), a)?, op, b) {141 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),142 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),143 (a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,144 })145}146147pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {148 Ok(match (a, op, b) {149 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,150151 (a, BinaryOpType::Eq, b) => Val::Bool(equals(&a, &b)?),152 (a, BinaryOpType::Neq, b) => Val::Bool(!equals(&a, &b)?),153154 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),155156 // Bool X Bool157 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),158 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),159160 // Str X Str161 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),162 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),163 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),164 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),165166 // Num X Num167 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,168 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {169 if *v2 <= f64::EPSILON {170 throw!(DivisionByZero)171 }172 Val::new_checked_num(v1 / v2)?173 }174175 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,176177 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),178 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),179 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),180 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),181182 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {183 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)184 }185 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {186 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)187 }188 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {189 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)190 }191 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {192 if *v2 < 0.0 {193 throw!(RuntimeError("shift by negative exponent".into()))194 }195 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)196 }197 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {198 if *v2 < 0.0 {199 throw!(RuntimeError("shift by negative exponent".into()))200 }201 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)202 }203204 _ => throw!(BinaryOperatorDoesNotOperateOnValues(205 op,206 a.value_type(),207 b.value_type(),208 )),209 })210}211212pub fn evaluate_comp<T>(213 context: Context,214 value: &impl Fn(Context) -> Result<T>,215 specs: &[CompSpec],216) -> Result<Option<Vec<T>>> {217 Ok(match specs.get(0) {218 None => Some(vec![value(context)?]),219 Some(CompSpec::IfSpec(IfSpecData(cond))) => {220 if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {221 evaluate_comp(context, value, &specs[1..])?222 } else {223 None224 }225 }226 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {227 Val::Arr(list) => {228 let mut out = Vec::new();229 for item in list.iter() {230 out.push(evaluate_comp(231 context.clone().with_var(var.clone(), item?.clone()),232 value,233 &specs[1..],234 )?);235 }236 Some(out.into_iter().flatten().flatten().collect())237 }238 _ => throw!(InComprehensionCanOnlyIterateOverArray),239 },240 })241}242243pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {244 let new_bindings = FutureWrapper::new();245 let future_this = FutureWrapper::new();246 let context_creator = ContextCreator(context.clone(), new_bindings.clone());247 {248 let mut bindings: FxHashMap<IStr, LazyBinding> =249 FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());250 for (n, b) in members251 .iter()252 .filter_map(|m| match m {253 Member::BindStmt(b) => Some(b.clone()),254 _ => None,255 })256 .map(|b| evaluate_binding(&b, context_creator.clone()))257 {258 bindings.insert(n, b);259 }260 new_bindings.fill(bindings);261 }262263 let mut new_members = FxHashMap::default();264 let mut assertions = Vec::new();265 for member in members.iter() {266 match member {267 Member::Field(FieldMember {268 name,269 plus,270 params: None,271 visibility,272 value,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.clone(),281 ObjMember {282 add: *plus,283 visibility: *visibility,284 invoke: LazyBinding::Bindable(Rc::new(285 closure!(clone name, clone value, clone context_creator, |this, super_obj| {286 Ok(LazyVal::new_resolved(evaluate_named(287 context_creator.create(this, super_obj)?,288 &value,289 name.clone(),290 )?))291 }),292 )),293 location: value.1.clone(),294 },295 );296 }297 Member::Field(FieldMember {298 name,299 params: Some(params),300 value,301 ..302 }) => {303 let name = evaluate_field_name(context.clone(), name)?;304 if name.is_none() {305 continue;306 }307 let name = name.unwrap();308 new_members.insert(309 name.clone(),310 ObjMember {311 add: false,312 visibility: Visibility::Hidden,313 invoke: LazyBinding::Bindable(Rc::new(314 closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {315 // TODO: Assert316 Ok(LazyVal::new_resolved(evaluate_method(317 context_creator.create(this, super_obj)?,318 name.clone(),319 params.clone(),320 value.clone(),321 )))322 }),323 )),324 location: value.1.clone(),325 },326 );327 }328 Member::BindStmt(_) => {}329 Member::AssertStmt(stmt) => {330 assertions.push(stmt.clone());331 }332 }333 }334 let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(assertions));335 future_this.fill(this.clone());336 Ok(this)337}338339pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {340 Ok(match object {341 ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,342 ObjBody::ObjComp(obj) => {343 let future_this = FutureWrapper::new();344 let mut new_members = FxHashMap::default();345 for (k, v) in evaluate_comp(346 context.clone(),347 &|ctx| {348 let new_bindings = FutureWrapper::new();349 let context_creator = ContextCreator(context.clone(), new_bindings.clone());350 let mut bindings: FxHashMap<IStr, LazyBinding> = FxHashMap::with_capacity_and_hasher(obj.pre_locals.len() + obj.post_locals.len(), BuildHasherDefault::default());351 for (n, b) in obj352 .pre_locals353 .iter()354 .chain(obj.post_locals.iter())355 .map(|b| evaluate_binding(b, context_creator.clone()))356 {357 bindings.insert(n, b);358 }359 new_bindings.fill(bindings.clone());360 let ctx = ctx.extend_unbound(bindings, None, None, None)?;361 let key = evaluate(ctx.clone(), &obj.key)?;362 let value = LazyBinding::Bindable(Rc::new(363 closure!(clone ctx, clone obj.value, |this, _super_obj| {364 Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))365 }),366 ));367368 Ok((key, value))369 },370 &obj.compspecs,371 )?372 .unwrap()373 {374 match k {375 Val::Null => {}376 Val::Str(n) => {377 new_members.insert(378 n,379 ObjMember {380 add: false,381 visibility: Visibility::Normal,382 invoke: v,383 location: obj.value.1.clone(),384 },385 );386 }387 v => throw!(FieldMustBeStringGot(v.value_type())),388 }389 }390391 let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(Vec::new()));392 future_this.fill(this.clone());393 this394 }395 })396}397398pub fn evaluate_apply(399 context: Context,400 value: &LocExpr,401 args: &ArgsDesc,402 loc: Option<&ExprLocation>,403 tailstrict: bool,404) -> Result<Val> {405 let value = evaluate(context.clone(), value)?;406 Ok(match value {407 Val::Func(f) => {408 let body = || f.evaluate(context, loc, args, tailstrict);409 if tailstrict {410 body()?411 } else {412 push(loc, || format!("function <{}> call", f.name()), body)?413 }414 }415 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),416 })417}418419pub fn evaluate_assert(420 context: Context,421 assertion: &AssertStmt,422) -> Result<()> {423 let value = &assertion.0;424 let msg = &assertion.1;425 let assertion_result = push(426 value.1.as_ref(),427 || "assertion condition".to_owned(),428 || {429 evaluate(context.clone(), value)?430 .try_cast_bool("assertion condition should be of type `boolean`")431 },432 )?;433 if !assertion_result {434 push(435 value.1.as_ref(),436 || "assertion failure".to_owned(),437 || {438 if let Some(msg) = msg {439 throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));440 } else {441 throw!(AssertionFailed(Val::Null.to_string()?));442 }443 },444 )?445 }446 Ok(())447}448449pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {450 use Expr::*;451 let LocExpr(expr, _loc) = lexpr;452 Ok(match &**expr {453 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),454 _ => evaluate(context, lexpr)?,455 })456}457458pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {459 use Expr::*;460 let LocExpr(expr, loc) = expr;461 Ok(match &**expr {462 Literal(LiteralType::This) => {463 Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)464 }465 Literal(LiteralType::Super) => Val::Obj(466 context467 .super_obj()468 .clone()469 .ok_or(NoSuperFound)?470 .with_this(context.this().clone().unwrap()),471 ),472 Literal(LiteralType::Dollar) => {473 Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)474 }475 Literal(LiteralType::True) => Val::Bool(true),476 Literal(LiteralType::False) => Val::Bool(false),477 Literal(LiteralType::Null) => Val::Null,478 Parened(e) => evaluate(context, e)?,479 Str(v) => Val::Str(v.clone()),480 Num(v) => Val::new_checked_num(*v)?,481 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,482 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,483 Var(name) => push(484 loc.as_ref(),485 || format!("variable <{}>", name),486 || context.binding(name.clone())?.evaluate(),487 )?,488 Index(value, index) => {489 match (evaluate(context.clone(), value)?, evaluate(context, index)?) {490 (Val::Obj(v), Val::Str(s)) => {491 let sn = s.clone();492 push(493 loc.as_ref(),494 || format!("field <{}> access", sn),495 || {496 if let Some(v) = v.get(s.clone())? {497 Ok(v)498 } else if v.get("__intrinsic_namespace__".into())?.is_some() {499 Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))500 } else {501 throw!(NoSuchField(s))502 }503 },504 )?505 }506 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(507 ValType::Obj,508 ValType::Str,509 n.value_type(),510 )),511512 (Val::Arr(v), Val::Num(n)) => {513 if n.fract() > f64::EPSILON {514 throw!(FractionalIndex)515 }516 v.get(n as usize)?517 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?518 }519 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),520 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(521 ValType::Arr,522 ValType::Num,523 n.value_type(),524 )),525526 (Val::Str(s), Val::Num(n)) => Val::Str(527 s.chars()528 .skip(n as usize)529 .take(1)530 .collect::<String>()531 .into(),532 ),533 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(534 ValType::Str,535 ValType::Num,536 n.value_type(),537 )),538539 (v, _) => throw!(CantIndexInto(v.value_type())),540 }541 }542 LocalExpr(bindings, returned) => {543 let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(544 bindings.len(),545 BuildHasherDefault::<FxHasher>::default(),546 );547 let future_context = Context::new_future();548 for b in bindings {549 new_bindings.insert(550 b.name.clone(),551 evaluate_binding_in_future(b, future_context.clone()),552 );553 }554 let context = context555 .extend_bound(new_bindings)556 .into_future(future_context);557 evaluate(context, &returned.clone())?558 }559 Arr(items) => {560 let mut out = Vec::with_capacity(items.len());561 for item in items {562 out.push(LazyVal::new(Box::new(563 closure!(clone context, clone item, || {564 evaluate(context.clone(), &item)565 }),566 )));567 }568 Val::Arr(out.into())569 }570 ArrComp(expr, comp_specs) => Val::Arr(571 // First comp_spec should be for_spec, so no "None" possible here572 evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?573 .unwrap()574 .into(),575 ),576 Obj(body) => Val::Obj(evaluate_object(context, body)?),577 ObjExtend(s, t) => evaluate_add_op(578 &evaluate(context.clone(), s)?,579 &Val::Obj(evaluate_object(context, t)?),580 )?,581 Apply(value, args, tailstrict) => {582 evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?583 }584 Function(params, body) => {585 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())586 }587 Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),588 AssertExpr(assert, returned) => {589 evaluate_assert(context.clone(), &assert)?;590 evaluate(context, returned)?591 }592 ErrorStmt(e) => push(593 loc.as_ref(),594 || "error statement".to_owned(),595 || {596 throw!(RuntimeError(597 evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,598 ))599 },600 )?,601 IfElse {602 cond,603 cond_then,604 cond_else,605 } => {606 if push(607 loc.as_ref(),608 || "if condition".to_owned(),609 || evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),610 )? {611 evaluate(context, cond_then)?612 } else {613 match cond_else {614 Some(v) => evaluate(context, v)?,615 None => Val::Null,616 }617 }618 }619 Import(path) => {620 let mut tmp = loc621 .clone()622 .expect("imports cannot be used without loc_data")623 .0;624 let import_location = Rc::make_mut(&mut tmp);625 import_location.pop();626 push(627 loc.as_ref(),628 || format!("import {:?}", path),629 || with_state(|s| s.import_file(import_location, path)),630 )?631 }632 ImportStr(path) => {633 let mut tmp = loc634 .clone()635 .expect("imports cannot be used without loc_data")636 .0;637 let import_location = Rc::make_mut(&mut tmp);638 import_location.pop();639 Val::Str(with_state(|s| s.import_file_str(import_location, path))?)640 }641 })642}