difftreelog
refactor do not use evaluate_trivial in primary evaluate functio
in: master
1 file changed
crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth1use std::rc::Rc;23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_ir::{6 function::ParamName, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams,7 FieldMember, FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers,8 Spanned,9};10use jrsonnet_types::ValType;11use rustc_hash::FxHashMap;1213use self::destructure::destruct;14use crate::{15 arr::ArrValue,16 bail,17 destructure::evaluate_dest,18 error::{suggest_object_fields, ErrorKind::*},19 evaluate::operator::{evaluate_binary_op_special, evaluate_unary_op},20 function::{CallLocation, FuncDesc, FuncVal},21 gc::WithCapacityExt as _,22 in_frame,23 typed::{FromUntyped, IntoUntyped as _, Typed},24 val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},25 with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,26 ResultExt, SupThis, Unbound, Val,27};28pub mod destructure;29pub mod operator;3031// This is the amount of bytes that need to be left on the stack before increasing the size.32// It must be at least as large as the stack required by any code that does not call33// `ensure_sufficient_stack`.34const RED_ZONE: usize = 100 * 1024; // 100k3536// Only the first stack that is pushed, grows exponentially (2^n * STACK_PER_RECURSION) from then37// on. This flag has performance relevant characteristics. Don't set it too high.38const STACK_PER_RECURSION: usize = 1024 * 1024; // 1MB3940/// Grows the stack on demand to prevent stack overflow. Call this in strategic locations41/// to "break up" recursive calls. E.g. almost any call to `visit_expr` or equivalent can benefit42/// from this.43///44/// Should not be sprinkled around carelessly, as it causes a little bit of overhead.45#[inline]46pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {47 stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)48}4950pub fn evaluate_trivial(expr: &Expr) -> Option<Val> {51 fn is_trivial(expr: &Expr) -> bool {52 match expr {53 Expr::Str(_)54 | Expr::Num(_)55 | Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,56 Expr::Arr(a) => a.iter().all(is_trivial),57 _ => false,58 }59 }60 Some(match expr {61 Expr::Str(s) => Val::string(s.clone()),62 Expr::Num(n) => {63 Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))64 }65 Expr::Literal(LiteralType::False) => Val::Bool(false),66 Expr::Literal(LiteralType::True) => Val::Bool(true),67 Expr::Literal(LiteralType::Null) => Val::Null,68 Expr::Arr(n) => {69 if n.iter().any(|e| !is_trivial(e)) {70 return None;71 }72 Val::Arr(ArrValue::eager(73 n.iter()74 .map(evaluate_trivial)75 .map(|e| e.expect("checked trivial"))76 .collect(),77 ))78 }79 _ => return None,80 })81}8283pub fn evaluate_method(ctx: Context, name: IStr, params: ExprParams, body: Rc<Expr>) -> Val {84 Val::Func(FuncVal::Normal(Cc::new(FuncDesc {85 name,86 ctx,87 params,88 body,89 })))90}9192pub fn evaluate_field_name(ctx: Context, field_name: &Spanned<FieldName>) -> Result<Option<IStr>> {93 Ok(match &field_name.value {94 FieldName::Fixed(n) => Some(n.clone()),95 FieldName::Dyn(expr) => in_frame(96 CallLocation::new(&field_name.span),97 || "evaluating field name".to_string(),98 || {99 let v = evaluate(ctx, expr)?;100 Ok(if matches!(v, Val::Null) {101 None102 } else {103 Some(IStr::from_untyped(v)?)104 })105 },106 )?,107 })108}109110pub fn evaluate_comp(111 ctx: Context,112 specs: &[CompSpec],113 callback: &mut impl FnMut(Context) -> Result<()>,114) -> Result<()> {115 match specs.first() {116 None => callback(ctx)?,117 Some(CompSpec::IfSpec(IfSpecData { cond, span: _ })) => {118 if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {119 evaluate_comp(ctx, &specs[1..], callback)?;120 }121 }122 Some(CompSpec::ForSpec(ForSpecData {123 destruct: into,124 over,125 })) => {126 match evaluate(ctx.clone(), over)? {127 Val::Arr(list) => {128 for item in list.iter_lazy() {129 let fctx = Pending::new();130 let mut new_bindings = FxHashMap::with_capacity(into.binds_len());131 destruct(into, item, fctx.clone(), &mut new_bindings)?;132 let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);133134 evaluate_comp(ctx, &specs[1..], callback)?;135 }136 }137 #[cfg(feature = "exp-object-iteration")]138 Val::Obj(obj) => {139 for field in obj.fields(140 // TODO: Should there be ability to preserve iteration order?141 #[cfg(feature = "exp-preserve-order")]142 false,143 ) {144 let fctx = Pending::new();145 let mut new_bindings = FxHashMap::with_capacity(into.binds_len());146 let obj = obj.clone();147 let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![148 Thunk::evaluated(Val::string(field.clone())),149 Thunk!(move || obj.get(field).transpose().expect(150 "field exists, as field name was obtained from object.fields()",151 )),152 ])));153 destruct(into, value, fctx.clone(), &mut new_bindings)?;154 let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);155156 evaluate_comp(ctx, &specs[1..], callback)?;157 }158 }159 _ => bail!(InComprehensionCanOnlyIterateOverArray),160 }161 }162 }163 Ok(())164}165166trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}167impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}168169fn evaluate_object_locals(170 fctx: Context,171 locals: Rc<Vec<BindSpec>>,172) -> impl CloneableUnbound<Context> {173 #[derive(Trace, Clone)]174 struct UnboundLocals {175 fctx: Context,176 locals: Rc<Vec<BindSpec>>,177 }178 impl Unbound for UnboundLocals {179 type Bound = Context;180181 fn bind(&self, sup_this: SupThis) -> Result<Context> {182 let fctx = Context::new_future();183 let mut new_bindings =184 FxHashMap::with_capacity(self.locals.iter().map(BindSpec::binds_len).sum());185 for b in self.locals.iter() {186 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;187 }188189 let ctx = self.fctx.clone();190191 let ctx = ctx192 .extend_bindings_sup_this(new_bindings, sup_this)193 .into_future(fctx);194195 Ok(ctx)196 }197 }198199 UnboundLocals { fctx, locals }200}201202pub fn evaluate_field_member<B: Unbound<Bound = Context> + Clone>(203 builder: &mut ObjValueBuilder,204 ctx: Context,205 uctx: B,206 field: &FieldMember,207) -> Result<()> {208 let name = evaluate_field_name(ctx, &field.name)?;209 let Some(name) = name else {210 return Ok(());211 };212213 match field {214 FieldMember {215 plus,216 params: None,217 visibility,218 value,219 ..220 } => {221 #[derive(Trace)]222 struct UnboundValue<B: Trace> {223 uctx: B,224 value: Rc<Expr>,225 name: IStr,226 }227 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {228 type Bound = Val;229 fn bind(&self, sup_this: SupThis) -> Result<Val> {230 evaluate_named(self.uctx.bind(sup_this)?, &self.value, self.name.clone())231 }232 }233234 builder235 .field(name.clone())236 .with_add(*plus)237 .with_visibility(*visibility)238 .with_location(field.name.span.clone())239 .bindable(UnboundValue {240 uctx,241 value: value.clone(),242 name,243 })?;244 }245 FieldMember {246 params: Some(params),247 visibility,248 value,249 ..250 } => {251 #[derive(Trace)]252 struct UnboundMethod<B: Trace> {253 uctx: B,254 value: Rc<Expr>,255 params: ExprParams,256 name: IStr,257 }258 impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {259 type Bound = Val;260 fn bind(&self, sup_this: SupThis) -> Result<Val> {261 Ok(evaluate_method(262 self.uctx.bind(sup_this)?,263 self.name.clone(),264 self.params.clone(),265 self.value.clone(),266 ))267 }268 }269270 builder271 .field(name.clone())272 .with_visibility(*visibility)273 // .with_location(value.span())274 .bindable(UnboundMethod {275 uctx,276 value: value.clone(),277 params: params.clone(),278 name,279 })?;280 }281 }282 Ok(())283}284285#[derive(Trace, Clone)]286struct DirectUnbound(Context);287impl Unbound for DirectUnbound {288 type Bound = Context;289 fn bind(&self, sup_this: SupThis) -> Result<Context> {290 Ok(self291 .0292 .clone()293 .extend_bindings_sup_this(FxHashMap::new(), sup_this))294 }295}296297#[allow(clippy::too_many_lines)]298pub fn evaluate_member_list_object(299 super_obj: Option<ObjValue>,300 ctx: Context,301 members: &ObjMembers,302) -> Result<ObjValue> {303 #[derive(Trace)]304 struct ObjectAssert<B: Trace> {305 uctx: B,306 asserts: Rc<Vec<AssertStmt>>,307 }308 impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {309 fn run(&self, sup_this: SupThis) -> Result<()> {310 let ctx = self.uctx.bind(sup_this)?;311 for assert in &*self.asserts {312 evaluate_assert(ctx.clone(), assert)?;313 }314 Ok(())315 }316 }317318 let mut builder = ObjValueBuilder::new();319 if let Some(super_obj) = super_obj {320 builder.with_super(super_obj);321 }322323 if members.locals.is_empty() {324 // We can use the same context for all field evaluation, it doesn't depends on locals, only on this/super325 let uctx = DirectUnbound(ctx.clone());326 for field in &members.fields {327 evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;328 }329 if !members.asserts.is_empty() {330 builder.assert(ObjectAssert {331 uctx,332 asserts: members.asserts.clone(),333 });334 }335 } else {336 let locals = members.locals.clone();337 // We have single context for all fields, so we can cache them together338 let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));339 for field in &members.fields {340 evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;341 }342 if !members.asserts.is_empty() {343 builder.assert(ObjectAssert {344 uctx,345 asserts: members.asserts.clone(),346 });347 }348 }349350 Ok(builder.build())351}352353pub fn evaluate_object(354 super_obj: Option<ObjValue>,355 ctx: Context,356 object: &ObjBody,357) -> Result<ObjValue> {358 Ok(match object {359 ObjBody::MemberList(members) => evaluate_member_list_object(super_obj, ctx, members)?,360 ObjBody::ObjComp(obj) => {361 let mut builder = ObjValueBuilder::new();362 if let Some(super_obj) = super_obj {363 builder.with_super(super_obj);364 }365 let locals = obj.locals.clone();366 evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {367 let uctx = evaluate_object_locals(ctx.clone(), locals.clone());368369 evaluate_field_member(&mut builder, ctx, uctx, &obj.field)370 })?;371372 builder.build()373 }374 })375}376377pub fn evaluate_apply(378 ctx: Context,379 value: &Expr,380 args: &ArgsDesc,381 loc: CallLocation<'_>,382 tailstrict: bool,383) -> Result<Val> {384 let value = evaluate(ctx.clone(), value)?;385 Ok(match value {386 Val::Func(f) => {387 let body = || f.evaluate(ctx, loc, args, tailstrict);388 if tailstrict {389 body()?390 } else {391 in_frame(loc, || format!("function <{}> call", f.name()), body)?392 }393 }394 v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),395 })396}397398pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {399 let value = &assertion.0;400 let msg = &assertion.1;401 let assertion_result = in_frame(402 CallLocation::new(&value.span),403 || "assertion condition".to_owned(),404 || bool::from_untyped(evaluate(ctx.clone(), value)?),405 )?;406 if !assertion_result {407 in_frame(408 CallLocation::new(&value.span),409 || "assertion failure".to_owned(),410 || {411 if let Some(msg) = msg {412 bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));413 }414 bail!(AssertionFailed(Val::Null.to_string()?));415 },416 )?;417 }418 Ok(())419}420421pub fn evaluate_named_param(ctx: Context, expr: &Expr, name: ParamName) -> Result<Val> {422 match name {423 ParamName::Named(name) => evaluate_named(ctx, expr, name),424 ParamName::Unnamed => evaluate(ctx, expr),425 }426}427428pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {429 use Expr::*;430 Ok(match expr {431 Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),432 _ => evaluate(ctx, expr)?,433 })434}435436#[allow(clippy::too_many_lines)]437pub fn evaluate(ctx: Context, expr: &Expr) -> Result<Val> {438 use Expr::*;439440 if let Some(trivial) = evaluate_trivial(expr) {441 return Ok(trivial);442 }443 Ok(match expr {444 Literal(LiteralType::This) => Val::Obj(ctx.try_this()?),445 Literal(LiteralType::Super) => Val::Obj(ctx.try_sup_this()?.standalone_super()?),446 Literal(LiteralType::Dollar) => Val::Obj(ctx.try_dollar()?),447 Literal(LiteralType::True) => Val::Bool(true),448 Literal(LiteralType::False) => Val::Bool(false),449 Literal(LiteralType::Null) => Val::Null,450 Str(v) => Val::string(v.clone()),451 Num(v) => Val::try_num(*v)?,452 // I have tried to remove special behavior from super by implementing standalone-super453 // expresion, but looks like this case still needs special treatment.454 //455 // Note that other jsonnet implementations will fail on `if value in (super)` expression,456 // because the standalone super literal is not supported, that is because in other457 // implementations `in super` treated differently from `in smth_else`.458 BinaryOp(bin)459 if matches!(&bin.rhs, Expr::Literal(LiteralType::Super))460 && bin.op == BinaryOpType::In =>461 {462 let sup_this = ctx.try_sup_this()?;463 // In jsonnet, "field" in e is eager, LHS expression is always executed regardless of super existence.464 // In jrsonnet, however, this wasn't true, this was kept here for compatibility.465 if !sup_this.has_super() {466 return Ok(Val::Bool(false));467 }468 let field = evaluate(ctx, &bin.lhs)?;469 Val::Bool(sup_this.field_in_super(field.to_string()?))470 }471 BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,472 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,473 Var(name) => in_frame(474 CallLocation::new(&name.span),475 || format!("local <{}> access", &**name),476 || ctx.binding((**name).clone())?.evaluate(),477 )?,478 Index { indexable, parts } => ensure_sufficient_stack(|| {479 let mut parts = parts.iter();480 let mut indexable = if matches!(&**indexable, Expr::Literal(LiteralType::Super)) {481 let part = parts.next().expect("at least part should exist");482 // sup_this existence check might also be skipped here for null-coalesce...483 // But I believe this might cause errors.484 let sup_this = ctx.try_sup_this()?;485 if !sup_this.has_super() {486 #[cfg(feature = "exp-null-coaelse")]487 if part.null_coaelse {488 return Ok(Val::Null);489 }490 bail!(NoSuperFound)491 }492 let name = evaluate(ctx.clone(), &part.value)?;493494 let Val::Str(name) = name else {495 bail!(ValueIndexMustBeTypeGot(496 ValType::Obj,497 ValType::Str,498 name.value_type(),499 ))500 };501502 let name = name.into_flat();503 match sup_this504 .get_super(name.clone())505 .with_description_src(&part.span, || format!("field <{name}> access"))?506 {507 Some(v) => v,508 #[cfg(feature = "exp-null-coaelse")]509 None if part.null_coaelse => return Ok(Val::Null),510 None => {511 let suggestions = suggest_object_fields(512 &sup_this.standalone_super().expect("super exists"),513 name.clone(),514 );515516 bail!(NoSuchField(name, suggestions))517 }518 }519 } else {520 evaluate(ctx.clone(), indexable)?521 };522523 for part in parts {524 indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {525 (Val::Obj(v), Val::Str(key)) => match v526 .get(key.clone().into_flat())527 .with_description_src(&part.span, || format!("field <{key}> access"))?528 {529 Some(v) => v,530 #[cfg(feature = "exp-null-coaelse")]531 None if part.null_coaelse => return Ok(Val::Null),532 None => {533 let suggestions = suggest_object_fields(&v, key.clone().into_flat());534535 return Err(Error::from(NoSuchField(536 key.clone().into_flat(),537 suggestions,538 )))539 .with_description_src(&part.span, || format!("field <{key}> access"));540 }541 },542 (Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(543 ValType::Obj,544 ValType::Str,545 n.value_type(),546 )),547 (Val::Arr(v), Val::Num(n)) => {548 let n = n.get();549 if n.fract() > f64::EPSILON {550 bail!(FractionalIndex)551 }552 if n < 0.0 {553 bail!(ArrayBoundsError(n as isize, v.len()));554 }555 v.get(n as usize)?556 .ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?557 }558 (Val::Arr(_), Val::Str(n)) => {559 bail!(AttemptedIndexAnArrayWithString(n.into_flat()))560 }561 (Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(562 ValType::Arr,563 ValType::Num,564 n.value_type(),565 )),566567 (Val::Str(s), Val::Num(n)) => Val::Str({568 let n = n.get();569 if n.fract() > f64::EPSILON {570 bail!(FractionalIndex)571 }572 if n < 0.0 {573 bail!(ArrayBoundsError(n as isize, s.into_flat().chars().count()));574 }575 let v: IStr = s576 .clone()577 .into_flat()578 .chars()579 .skip(n as usize)580 .take(1)581 .collect::<String>()582 .into();583 if v.is_empty() {584 bail!(StringBoundsError(n as usize, s.into_flat().chars().count()))585 }586 StrValue::Flat(v)587 }),588 (Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(589 ValType::Str,590 ValType::Num,591 n.value_type(),592 )),593 #[cfg(feature = "exp-null-coaelse")]594 (Val::Null, _) if part.null_coaelse => return Ok(Val::Null),595 (v, _) => bail!(CantIndexInto(v.value_type())),596 };597 }598 Ok(indexable)599 })?,600 LocalExpr(bindings, returned) => {601 let mut new_bindings: FxHashMap<IStr, Thunk<Val>> =602 FxHashMap::with_capacity(bindings.iter().map(BindSpec::binds_len).sum());603 let fctx = Context::new_future();604 for b in bindings {605 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;606 }607 let ctx = ctx.extend_bindings(new_bindings).into_future(fctx);608 evaluate(ctx, returned)?609 }610 Arr(items) => {611 if items.is_empty() {612 Val::Arr(ArrValue::empty())613 } else {614 Val::Arr(ArrValue::expr(ctx, items.clone()))615 }616 }617 ArrComp(expr, comp_specs) => {618 let mut out = Vec::new();619 evaluate_comp(ctx, comp_specs, &mut |ctx| {620 let expr = expr.clone();621 out.push(Thunk!(move || evaluate(ctx, &expr)));622 Ok(())623 })?;624 Val::Arr(ArrValue::lazy(out))625 }626 Obj(body) => Val::Obj(evaluate_object(None, ctx, body)?),627 ObjExtend(a, b) => {628 let base = evaluate(ctx.clone(), a)?;629 match base {630 Val::Obj(base_obj) => Val::Obj(evaluate_object(Some(base_obj), ctx, b)?),631 _ => bail!("ObjExtend lhs should be an object value"),632 }633 }634 Apply(value, args, tailstrict) => ensure_sufficient_stack(|| {635 evaluate_apply(ctx, value, args, CallLocation::new(&args.span), *tailstrict)636 })?,637 Function(params, body) => {638 evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())639 }640 AssertExpr(assert) => {641 evaluate_assert(ctx.clone(), &assert.assert)?;642 evaluate(ctx, &assert.rest)?643 }644 ErrorStmt(s, e) => in_frame(645 CallLocation::new(s),646 || "error statement".to_owned(),647 || bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),648 )?,649 IfElse(if_else) => {650 if in_frame(651 CallLocation::new(&if_else.cond.span),652 || "if condition".to_owned(),653 || bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.cond)?),654 )? {655 evaluate(ctx, &if_else.cond_then)?656 } else {657 match &if_else.cond_else {658 Some(v) => evaluate(ctx, v)?,659 None => Val::Null,660 }661 }662 }663 Slice(slice) => {664 fn parse_idx<T: Typed + FromUntyped>(665 ctx: Context,666 expr: Option<&Spanned<Expr>>,667 desc: &'static str,668 ) -> Result<Option<T>> {669 if let Some(value) = expr {670 Ok(in_frame(671 CallLocation::new(&value.span),672 || format!("slice {desc}"),673 || <Option<T>>::from_untyped(evaluate(ctx, value)?),674 )?)675 } else {676 Ok(None)677 }678 }679680 let indexable = evaluate(ctx.clone(), &slice.value)?;681682 let start = parse_idx(ctx.clone(), slice.slice.start.as_ref(), "start")?;683 let end = parse_idx(ctx.clone(), slice.slice.end.as_ref(), "end")?;684 let step = parse_idx(ctx, slice.slice.step.as_ref(), "step")?;685686 IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?687 }688 Import(kind, path) => {689 let Expr::Str(path) = &**path else {690 bail!("computed imports are not supported")691 };692 with_state(|s| {693 let span = &kind.span;694 let resolved_path = s.resolve_from(span.0.source_path(), path)?;695 Ok(match &**kind {696 ImportKind::Normal => in_frame(697 CallLocation::new(span),698 || format!("import {:?}", path.clone()),699 || s.import_resolved(resolved_path),700 )?,701 ImportKind::Str => Val::string(s.import_resolved_str(resolved_path)?),702 ImportKind::Bin => {703 Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))704 }705 }) as Result<Val>706 })?707 }708 })709}