1use std::rc::Rc;23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,7 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,8};9use jrsonnet_types::ValType;1011use self::destructure::destruct;12use crate::{13 arr::ArrValue,14 bail,15 destructure::evaluate_dest,16 error::{suggest_object_fields, ErrorKind::*},17 evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},18 function::{CallLocation, FuncDesc, FuncVal},19 typed::Typed,20 val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk, ThunkValue},21 Context, Error, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,22 ResultExt, State, Unbound, Val,23};24pub mod destructure;25pub mod operator;2627pub fn evaluate_trivial(expr: &LocExpr) -> Option<Val> {28 fn is_trivial(expr: &LocExpr) -> bool {29 match expr.expr() {30 Expr::Str(_)31 | Expr::Num(_)32 | Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,33 Expr::Arr(a) => a.iter().all(is_trivial),34 Expr::Parened(e) => is_trivial(e),35 _ => false,36 }37 }38 Some(match expr.expr() {39 Expr::Str(s) => Val::string(s.clone()),40 Expr::Num(n) => {41 Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))42 }43 Expr::Literal(LiteralType::False) => Val::Bool(false),44 Expr::Literal(LiteralType::True) => Val::Bool(true),45 Expr::Literal(LiteralType::Null) => Val::Null,46 Expr::Arr(n) => {47 if n.iter().any(|e| !is_trivial(e)) {48 return None;49 }50 Val::Arr(ArrValue::eager(51 n.iter()52 .map(evaluate_trivial)53 .map(|e| e.expect("checked trivial"))54 .collect(),55 ))56 }57 Expr::Parened(e) => evaluate_trivial(e)?,58 _ => return None,59 })60}6162pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {63 Val::Func(FuncVal::Normal(Cc::new(FuncDesc {64 name,65 ctx,66 params,67 body,68 })))69}7071pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {72 Ok(match field_name {73 FieldName::Fixed(n) => Some(n.clone()),74 FieldName::Dyn(expr) => State::push(75 CallLocation::new(&expr.span()),76 || "evaluating field name".to_string(),77 || {78 let value = evaluate(ctx, expr)?;79 if matches!(value, Val::Null) {80 Ok(None)81 } else {82 Ok(Some(IStr::from_untyped(value)?))83 }84 },85 )?,86 })87}8889pub fn evaluate_comp(90 ctx: Context,91 specs: &[CompSpec],92 callback: &mut impl FnMut(Context) -> Result<()>,93) -> Result<()> {94 match specs.first() {95 None => callback(ctx)?,96 Some(CompSpec::IfSpec(IfSpecData(cond))) => {97 if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {98 evaluate_comp(ctx, &specs[1..], callback)?;99 }100 }101 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {102 Val::Arr(list) => {103 for item in list.iter_lazy() {104 let fctx = Pending::new();105 let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());106 destruct(var, item, fctx.clone(), &mut new_bindings)?;107 let ctx = ctx108 .clone()109 .extend(new_bindings, None, None, None)110 .into_future(fctx);111112 evaluate_comp(ctx, &specs[1..], callback)?;113 }114 }115 #[cfg(feature = "exp-object-iteration")]116 Val::Obj(obj) => {117 for field in obj.fields(118 119 #[cfg(feature = "exp-preserve-order")]120 false,121 ) {122 #[derive(Trace)]123 struct ObjectFieldThunk {124 obj: ObjValue,125 field: IStr,126 }127 impl ThunkValue for ObjectFieldThunk {128 type Output = Val;129130 fn get(self: Box<Self>) -> Result<Self::Output> {131 self.obj.get(self.field).transpose().expect(132 "field exists, as field name was obtained from object.fields()",133 )134 }135 }136137 let fctx = Pending::new();138 let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());139 let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![140 Thunk::evaluated(Val::string(field.clone())),141 Thunk::new(ObjectFieldThunk {142 field: field.clone(),143 obj: obj.clone(),144 }),145 ])));146 destruct(var, value, fctx.clone(), &mut new_bindings)?;147 let ctx = ctx148 .clone()149 .extend(new_bindings, None, None, None)150 .into_future(fctx);151152 evaluate_comp(ctx, &specs[1..], callback)?;153 }154 }155 _ => bail!(InComprehensionCanOnlyIterateOverArray),156 },157 }158 Ok(())159}160161trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}162impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}163164fn evaluate_object_locals(165 fctx: Pending<Context>,166 locals: Rc<Vec<BindSpec>>,167) -> impl CloneableUnbound<Context> {168 #[derive(Trace, Clone)]169 struct UnboundLocals {170 fctx: Pending<Context>,171 locals: Rc<Vec<BindSpec>>,172 }173 impl Unbound for UnboundLocals {174 type Bound = Context;175176 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Context> {177 let fctx = Context::new_future();178 let mut new_bindings =179 GcHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());180 for b in self.locals.iter() {181 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;182 }183184 let ctx = self.fctx.unwrap();185 let new_dollar = ctx.dollar().cloned().or_else(|| this.clone());186187 let ctx = ctx188 .extend(new_bindings, new_dollar, sup, this)189 .into_future(fctx);190191 Ok(ctx)192 }193 }194195 UnboundLocals { fctx, locals }196}197198pub fn evaluate_field_member<B: Unbound<Bound = Context> + Clone>(199 builder: &mut ObjValueBuilder,200 ctx: Context,201 uctx: B,202 field: &FieldMember,203) -> Result<()> {204 let name = evaluate_field_name(ctx, &field.name)?;205 let Some(name) = name else {206 return Ok(());207 };208209 match field {210 FieldMember {211 plus,212 params: None,213 visibility,214 value,215 ..216 } => {217 #[derive(Trace)]218 struct UnboundValue<B: Trace> {219 uctx: B,220 value: LocExpr,221 name: IStr,222 }223 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {224 type Bound = Val;225 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {226 evaluate_named(self.uctx.bind(sup, this)?, &self.value, self.name.clone())227 }228 }229230 builder231 .field(name.clone())232 .with_add(*plus)233 .with_visibility(*visibility)234 .with_location(value.span())235 .bindable(UnboundValue {236 uctx,237 value: value.clone(),238 name,239 })?;240 }241 FieldMember {242 params: Some(params),243 visibility,244 value,245 ..246 } => {247 #[derive(Trace)]248 struct UnboundMethod<B: Trace> {249 uctx: B,250 value: LocExpr,251 params: ParamsDesc,252 name: IStr,253 }254 impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {255 type Bound = Val;256 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {257 Ok(evaluate_method(258 self.uctx.bind(sup, this)?,259 self.name.clone(),260 self.params.clone(),261 self.value.clone(),262 ))263 }264 }265266 builder267 .field(name.clone())268 .with_visibility(*visibility)269 .with_location(value.span())270 .bindable(UnboundMethod {271 uctx,272 value: value.clone(),273 params: params.clone(),274 name,275 })?;276 }277 }278 Ok(())279}280281#[allow(clippy::too_many_lines)]282pub fn evaluate_member_list_object(ctx: Context, members: &[Member]) -> Result<ObjValue> {283 let mut builder = ObjValueBuilder::new();284 let locals = Rc::new(285 members286 .iter()287 .filter_map(|m| match m {288 Member::BindStmt(bind) => Some(bind.clone()),289 _ => None,290 })291 .collect::<Vec<_>>(),292 );293294 let fctx = Context::new_future();295296 297 let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));298299 for member in members {300 match member {301 Member::Field(field) => {302 evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;303 }304 Member::AssertStmt(stmt) => {305 #[derive(Trace)]306 struct ObjectAssert<B: Trace> {307 uctx: B,308 assert: AssertStmt,309 }310 impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {311 fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {312 let ctx = self.uctx.bind(sup, this)?;313 evaluate_assert(ctx, &self.assert)314 }315 }316 builder.assert(ObjectAssert {317 uctx: uctx.clone(),318 assert: stmt.clone(),319 });320 }321 Member::BindStmt(_) => {322 323 }324 }325 }326 let this = builder.build();327 fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));328 Ok(this)329}330331pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {332 Ok(match object {333 ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,334 ObjBody::ObjComp(obj) => {335 let mut builder = ObjValueBuilder::new();336 let locals = Rc::new(337 obj.pre_locals338 .iter()339 .chain(obj.post_locals.iter())340 .cloned()341 .collect::<Vec<_>>(),342 );343 let mut ctxs = vec![];344 evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {345 let fctx = Context::new_future();346 ctxs.push((ctx.clone(), fctx.clone()));347 let uctx = evaluate_object_locals(fctx, locals.clone());348349 evaluate_field_member(&mut builder, ctx, uctx, &obj.field)350 })?;351352 let this = builder.build();353 for (ctx, fctx) in ctxs {354 let _ctx = ctx355 .extend(GcHashMap::new(), None, None, Some(this.clone()))356 .into_future(fctx);357 }358 this359 }360 })361}362363pub fn evaluate_apply(364 ctx: Context,365 value: &LocExpr,366 args: &ArgsDesc,367 loc: CallLocation<'_>,368 tailstrict: bool,369) -> Result<Val> {370 let value = evaluate(ctx.clone(), value)?;371 Ok(match value {372 Val::Func(f) => {373 let body = || f.evaluate(ctx, loc, args, tailstrict);374 if tailstrict {375 body()?376 } else {377 State::push(loc, || format!("function <{}> call", f.name()), body)?378 }379 }380 v => bail!(OnlyFunctionsCanBeCalledGot(v.value_type())),381 })382}383384pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {385 let value = &assertion.0;386 let msg = &assertion.1;387 let assertion_result = State::push(388 CallLocation::new(&value.span()),389 || "assertion condition".to_owned(),390 || bool::from_untyped(evaluate(ctx.clone(), value)?),391 )?;392 if !assertion_result {393 State::push(394 CallLocation::new(&value.span()),395 || "assertion failure".to_owned(),396 || {397 if let Some(msg) = msg {398 bail!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));399 }400 bail!(AssertionFailed(Val::Null.to_string()?));401 },402 )?;403 }404 Ok(())405}406407pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {408 use Expr::*;409 Ok(match expr.expr() {410 Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),411 _ => evaluate(ctx, expr)?,412 })413}414415#[allow(clippy::too_many_lines)]416pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {417 use Expr::*;418419 if let Some(trivial) = evaluate_trivial(expr) {420 return Ok(trivial);421 }422 let loc = expr.span();423 Ok(match expr.expr() {424 Literal(LiteralType::This) => {425 Val::Obj(ctx.this().ok_or(CantUseSelfOutsideOfObject)?.clone())426 }427 Literal(LiteralType::Super) => Val::Obj(428 ctx.super_obj().ok_or(NoSuperFound)?.with_this(429 ctx.this()430 .expect("if super exists - then this should too")431 .clone(),432 ),433 ),434 Literal(LiteralType::Dollar) => {435 Val::Obj(ctx.dollar().ok_or(NoTopLevelObjectFound)?.clone())436 }437 Literal(LiteralType::True) => Val::Bool(true),438 Literal(LiteralType::False) => Val::Bool(false),439 Literal(LiteralType::Null) => Val::Null,440 Parened(e) => evaluate(ctx, e)?,441 Str(v) => Val::string(v.clone()),442 Num(v) => Val::try_num(*v)?,443 444 445 446 447 448 449 BinaryOp(field, BinaryOpType::In, e)450 if matches!(e.expr(), Expr::Literal(LiteralType::Super)) =>451 {452 let Some(super_obj) = ctx.super_obj() else {453 return Ok(Val::Bool(false));454 };455 let field = evaluate(ctx.clone(), field)?;456 Val::Bool(super_obj.has_field_ex(field.to_string()?, true))457 }458 BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,459 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,460 Var(name) => State::push(461 CallLocation::new(&loc),462 || format!("variable <{name}> access"),463 || ctx.binding(name.clone())?.evaluate(),464 )?,465 Index { indexable, parts } => {466 let mut parts = parts.iter();467 let mut indexable = if matches!(indexable.expr(), Expr::Literal(LiteralType::Super)) {468 let part = parts.next().expect("at least part should exist");469 let Some(super_obj) = ctx.super_obj() else {470 #[cfg(feature = "exp-null-coaelse")]471 if part.null_coaelse {472 return Ok(Val::Null);473 }474 bail!(NoSuperFound)475 };476 let name = evaluate(ctx.clone(), &part.value)?;477478 let Val::Str(name) = name else {479 bail!(ValueIndexMustBeTypeGot(480 ValType::Obj,481 ValType::Str,482 name.value_type(),483 ))484 };485486 let this = ctx487 .this()488 .expect("no this found, while super present, should not happen");489 let name = name.into_flat();490 match super_obj491 .get_for(name.clone(), this.clone())492 .with_description_src(&part.value, || format!("field <{name}> access"))?493 {494 Some(v) => v,495 #[cfg(feature = "exp-null-coaelse")]496 None if part.null_coaelse => return Ok(Val::Null),497 None => {498 let suggestions = suggest_object_fields(super_obj, name.clone());499500 bail!(NoSuchField(name, suggestions))501 }502 }503 } else {504 evaluate(ctx.clone(), indexable)?505 };506507 for part in parts {508 indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {509 (Val::Obj(v), Val::Str(key)) => match v510 .get(key.clone().into_flat())511 .with_description_src(&part.value, || format!("field <{key}> access"))?512 {513 Some(v) => v,514 #[cfg(feature = "exp-null-coaelse")]515 None if part.null_coaelse => return Ok(Val::Null),516 None => {517 let suggestions = suggest_object_fields(&v, key.clone().into_flat());518519 return Err(Error::from(NoSuchField(520 key.clone().into_flat(),521 suggestions,522 )))523 .with_description_src(&part.value, || format!("field <{key}> access"));524 }525 },526 (Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(527 ValType::Obj,528 ValType::Str,529 n.value_type(),530 )),531 (Val::Arr(v), Val::Num(n)) => {532 let n = n.get();533 if n.fract() > f64::EPSILON {534 bail!(FractionalIndex)535 }536 if n < 0.0 {537 bail!(ArrayBoundsError(n as isize, v.len()));538 }539 v.get(n as usize)?540 .ok_or_else(|| ArrayBoundsError(n as isize, v.len()))?541 }542 (Val::Arr(_), Val::Str(n)) => {543 bail!(AttemptedIndexAnArrayWithString(n.into_flat()))544 }545 (Val::Arr(_), n) => bail!(ValueIndexMustBeTypeGot(546 ValType::Arr,547 ValType::Num,548 n.value_type(),549 )),550551 (Val::Str(s), Val::Num(n)) => Val::Str({552 let v: IStr = s553 .clone()554 .into_flat()555 .chars()556 .skip(n.get() as usize)557 .take(1)558 .collect::<String>()559 .into();560 if v.is_empty() {561 let size = s.into_flat().chars().count();562 bail!(StringBoundsError(n.get() as usize, size))563 }564 StrValue::Flat(v)565 }),566 (Val::Str(_), n) => bail!(ValueIndexMustBeTypeGot(567 ValType::Str,568 ValType::Num,569 n.value_type(),570 )),571 #[cfg(feature = "exp-null-coaelse")]572 (Val::Null, _) if part.null_coaelse => return Ok(Val::Null),573 (v, _) => bail!(CantIndexInto(v.value_type())),574 };575 }576 indexable577 }578 LocalExpr(bindings, returned) => {579 let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =580 GcHashMap::with_capacity(bindings.iter().map(BindSpec::capacity_hint).sum());581 let fctx = Context::new_future();582 for b in bindings {583 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;584 }585 let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);586 evaluate(ctx, &returned.clone())?587 }588 Arr(items) => {589 if items.is_empty() {590 Val::Arr(ArrValue::empty())591 } else if items.len() == 1 {592 #[derive(Trace)]593 struct ArrayElement {594 ctx: Context,595 item: LocExpr,596 }597 impl ThunkValue for ArrayElement {598 type Output = Val;599 fn get(self: Box<Self>) -> Result<Val> {600 evaluate(self.ctx, &self.item)601 }602 }603 Val::Arr(ArrValue::lazy(vec![Thunk::new(ArrayElement {604 ctx,605 item: items[0].clone(),606 })]))607 } else {608 Val::Arr(ArrValue::expr(ctx, items.iter().cloned()))609 }610 }611 ArrComp(expr, comp_specs) => {612 let mut out = Vec::new();613 evaluate_comp(ctx, comp_specs, &mut |ctx| {614 #[derive(Trace)]615 struct EvaluateThunk {616 ctx: Context,617 expr: LocExpr,618 }619 impl ThunkValue for EvaluateThunk {620 type Output = Val;621 fn get(self: Box<Self>) -> Result<Val> {622 evaluate(self.ctx, &self.expr)623 }624 }625 out.push(Thunk::new(EvaluateThunk {626 ctx,627 expr: expr.clone(),628 }));629 Ok(())630 })?;631 Val::Arr(ArrValue::lazy(out))632 }633 Obj(body) => Val::Obj(evaluate_object(ctx, body)?),634 ObjExtend(a, b) => evaluate_add_op(635 &evaluate(ctx.clone(), a)?,636 &Val::Obj(evaluate_object(ctx, b)?),637 )?,638 Apply(value, args, tailstrict) => {639 evaluate_apply(ctx, value, args, CallLocation::new(&loc), *tailstrict)?640 }641 Function(params, body) => {642 evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())643 }644 AssertExpr(assert, returned) => {645 evaluate_assert(ctx.clone(), assert)?;646 evaluate(ctx, returned)?647 }648 ErrorStmt(e) => State::push(649 CallLocation::new(&loc),650 || "error statement".to_owned(),651 || bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),652 )?,653 IfElse {654 cond,655 cond_then,656 cond_else,657 } => {658 if State::push(659 CallLocation::new(&loc),660 || "if condition".to_owned(),661 || bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),662 )? {663 evaluate(ctx, cond_then)?664 } else {665 match cond_else {666 Some(v) => evaluate(ctx, v)?,667 None => Val::Null,668 }669 }670 }671 Slice(value, desc) => {672 fn parse_idx<T: Typed>(673 loc: CallLocation<'_>,674 ctx: &Context,675 expr: Option<&LocExpr>,676 desc: &'static str,677 ) -> Result<Option<T>> {678 if let Some(value) = expr {679 Ok(Some(State::push(680 loc,681 || format!("slice {desc}"),682 || T::from_untyped(evaluate(ctx.clone(), value)?),683 )?))684 } else {685 Ok(None)686 }687 }688689 let indexable = evaluate(ctx.clone(), value)?;690 let loc = CallLocation::new(&loc);691692 let start = parse_idx(loc, &ctx, desc.start.as_ref(), "start")?;693 let end = parse_idx(loc, &ctx, desc.end.as_ref(), "end")?;694 let step = parse_idx(loc, &ctx, desc.step.as_ref(), "step")?;695696 IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?697 }698 i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {699 let Expr::Str(path) = &path.expr() else {700 bail!("computed imports are not supported")701 };702 let tmp = loc.clone().0;703 let s = ctx.state();704 let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;705 match i {706 Import(_) => State::push(707 CallLocation::new(&loc),708 || format!("import {:?}", path.clone()),709 || s.import_resolved(resolved_path),710 )?,711 ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),712 ImportBin(_) => Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?)),713 _ => unreachable!(),714 }715 }716 })717}