1use crate::{2 error::Error::*,3 evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},4 push, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,5 FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder, ObjectAssertion,6 Result, Val,7};8use jrsonnet_gc::{Gc, Trace};9use jrsonnet_interner::IStr;10use jrsonnet_parser::{11 ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, ExprLocation, FieldMember, ForSpecData,12 IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,13};14use jrsonnet_types::ValType;15use rustc_hash::{FxHashMap, FxHasher};16use std::{collections::HashMap, hash::BuildHasherDefault};17pub mod operator;1819pub fn evaluate_binding_in_future(20 b: &BindSpec,21 context_creator: FutureWrapper<Context>,22) -> LazyVal {23 let b = b.clone();24 if let Some(params) = &b.params {25 let params = params.clone();2627 #[derive(Trace)]28 #[trivially_drop]29 struct LazyMethodBinding {30 context_creator: FutureWrapper<Context>,31 name: IStr,32 params: ParamsDesc,33 value: LocExpr,34 }35 impl LazyValValue for LazyMethodBinding {36 fn get(self: Box<Self>) -> Result<Val> {37 Ok(evaluate_method(38 self.context_creator.unwrap(),39 self.name,40 self.params,41 self.value,42 ))43 }44 }4546 LazyVal::new(Box::new(LazyMethodBinding {47 context_creator,48 name: b.name.clone(),49 params,50 value: b.value.clone(),51 }))52 } else {53 #[derive(Trace)]54 #[trivially_drop]55 struct LazyNamedBinding {56 context_creator: FutureWrapper<Context>,57 name: IStr,58 value: LocExpr,59 }60 impl LazyValValue for LazyNamedBinding {61 fn get(self: Box<Self>) -> Result<Val> {62 evaluate_named(self.context_creator.unwrap(), &self.value, self.name)63 }64 }65 LazyVal::new(Box::new(LazyNamedBinding {66 context_creator,67 name: b.name.clone(),68 value: b.value,69 }))70 }71}7273pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {74 let b = b.clone();75 if let Some(params) = &b.params {76 let params = params.clone();7778 #[derive(Trace)]79 #[trivially_drop]80 struct BindableMethodLazyVal {81 this: Option<ObjValue>,82 super_obj: Option<ObjValue>,8384 context_creator: ContextCreator,85 name: IStr,86 params: ParamsDesc,87 value: LocExpr,88 }89 impl LazyValValue for BindableMethodLazyVal {90 fn get(self: Box<Self>) -> Result<Val> {91 Ok(evaluate_method(92 self.context_creator.create(self.this, self.super_obj)?,93 self.name,94 self.params,95 self.value,96 ))97 }98 }99100 #[derive(Trace)]101 #[trivially_drop]102 struct BindableMethod {103 context_creator: ContextCreator,104 name: IStr,105 params: ParamsDesc,106 value: LocExpr,107 }108 impl Bindable for BindableMethod {109 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {110 Ok(LazyVal::new(Box::new(BindableMethodLazyVal {111 this,112 super_obj,113114 context_creator: self.context_creator.clone(),115 name: self.name.clone(),116 params: self.params.clone(),117 value: self.value.clone(),118 })))119 }120 }121122 (123 b.name.clone(),124 LazyBinding::Bindable(Gc::new(Box::new(BindableMethod {125 context_creator,126 name: b.name.clone(),127 params,128 value: b.value.clone(),129 }))),130 )131 } else {132 #[derive(Trace)]133 #[trivially_drop]134 struct BindableNamedLazyVal {135 this: Option<ObjValue>,136 super_obj: Option<ObjValue>,137138 context_creator: ContextCreator,139 name: IStr,140 value: LocExpr,141 }142 impl LazyValValue for BindableNamedLazyVal {143 fn get(self: Box<Self>) -> Result<Val> {144 evaluate_named(145 self.context_creator.create(self.this, self.super_obj)?,146 &self.value,147 self.name,148 )149 }150 }151152 #[derive(Trace)]153 #[trivially_drop]154 struct BindableNamed {155 context_creator: ContextCreator,156 name: IStr,157 value: LocExpr,158 }159 impl Bindable for BindableNamed {160 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {161 Ok(LazyVal::new(Box::new(BindableNamedLazyVal {162 this,163 super_obj,164165 context_creator: self.context_creator.clone(),166 name: self.name.clone(),167 value: self.value.clone(),168 })))169 }170 }171172 (173 b.name.clone(),174 LazyBinding::Bindable(Gc::new(Box::new(BindableNamed {175 context_creator,176 name: b.name.clone(),177 value: b.value.clone(),178 }))),179 )180 }181}182183pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {184 Val::Func(Gc::new(FuncVal::Normal(FuncDesc {185 name,186 ctx,187 params,188 body,189 })))190}191192pub fn evaluate_field_name(193 context: Context,194 field_name: &jrsonnet_parser::FieldName,195) -> Result<Option<IStr>> {196 Ok(match field_name {197 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),198 jrsonnet_parser::FieldName::Dyn(expr) => {199 let value = evaluate(context, expr)?;200 if matches!(value, Val::Null) {201 None202 } else {203 Some(value.try_cast_str("dynamic field name")?)204 }205 }206 })207}208209pub fn evaluate_comp(210 context: Context,211 specs: &[CompSpec],212 callback: &mut impl FnMut(Context) -> Result<()>,213) -> Result<()> {214 match specs.get(0) {215 None => callback(context)?,216 Some(CompSpec::IfSpec(IfSpecData(cond))) => {217 if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {218 evaluate_comp(context, &specs[1..], callback)?219 }220 }221 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {222 Val::Arr(list) => {223 for item in list.iter() {224 evaluate_comp(225 context.clone().with_var(var.clone(), item?.clone()),226 &specs[1..],227 callback,228 )?229 }230 }231 _ => throw!(InComprehensionCanOnlyIterateOverArray),232 },233 }234 Ok(())235}236237pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {238 let new_bindings = FutureWrapper::new();239 let future_this = FutureWrapper::new();240 let context_creator = ContextCreator(context.clone(), new_bindings.clone());241 {242 let mut bindings: FxHashMap<IStr, LazyBinding> =243 FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());244 for (n, b) in members245 .iter()246 .filter_map(|m| match m {247 Member::BindStmt(b) => Some(b.clone()),248 _ => None,249 })250 .map(|b| evaluate_binding(&b, context_creator.clone()))251 {252 bindings.insert(n, b);253 }254 new_bindings.fill(bindings);255 }256257 let mut builder = ObjValueBuilder::new();258 for member in members.iter() {259 match member {260 Member::Field(FieldMember {261 name,262 plus,263 params: None,264 visibility,265 value,266 }) => {267 let name = evaluate_field_name(context.clone(), name)?;268 if name.is_none() {269 continue;270 }271 let name = name.unwrap();272273 #[derive(Trace)]274 #[trivially_drop]275 struct ObjMemberBinding {276 context_creator: ContextCreator,277 value: LocExpr,278 name: IStr,279 }280 impl Bindable for ObjMemberBinding {281 fn bind(282 &self,283 this: Option<ObjValue>,284 super_obj: Option<ObjValue>,285 ) -> Result<LazyVal> {286 Ok(LazyVal::new_resolved(evaluate_named(287 self.context_creator.create(this, super_obj)?,288 &self.value,289 self.name.clone(),290 )?))291 }292 }293 builder294 .member(name.clone())295 .with_add(*plus)296 .with_visibility(*visibility)297 .with_location(value.1.clone())298 .bindable(Box::new(ObjMemberBinding {299 context_creator: context_creator.clone(),300 value: value.clone(),301 name,302 }));303 }304 Member::Field(FieldMember {305 name,306 params: Some(params),307 value,308 ..309 }) => {310 let name = evaluate_field_name(context.clone(), name)?;311 if name.is_none() {312 continue;313 }314 let name = name.unwrap();315 #[derive(Trace)]316 #[trivially_drop]317 struct ObjMemberBinding {318 context_creator: ContextCreator,319 value: LocExpr,320 params: ParamsDesc,321 name: IStr,322 }323 impl Bindable for ObjMemberBinding {324 fn bind(325 &self,326 this: Option<ObjValue>,327 super_obj: Option<ObjValue>,328 ) -> Result<LazyVal> {329 Ok(LazyVal::new_resolved(evaluate_method(330 self.context_creator.create(this, super_obj)?,331 self.name.clone(),332 self.params.clone(),333 self.value.clone(),334 )))335 }336 }337 builder338 .member(name.clone())339 .hide()340 .with_location(value.1.clone())341 .binding(LazyBinding::Bindable(Gc::new(Box::new(ObjMemberBinding {342 context_creator: context_creator.clone(),343 value: value.clone(),344 params: params.clone(),345 name,346 }))));347 }348 Member::BindStmt(_) => {}349 Member::AssertStmt(stmt) => {350 #[derive(Trace)]351 #[trivially_drop]352 struct ObjectAssert {353 context_creator: ContextCreator,354 assert: AssertStmt,355 }356 impl ObjectAssertion for ObjectAssert {357 fn run(358 &self,359 this: Option<ObjValue>,360 super_obj: Option<ObjValue>,361 ) -> Result<()> {362 let ctx = self.context_creator.create(this, super_obj)?;363 evaluate_assert(ctx, &self.assert)364 }365 }366 builder.assert(Box::new(ObjectAssert {367 context_creator: context_creator.clone(),368 assert: stmt.clone(),369 }));370 }371 }372 }373 let this = builder.build();374 future_this.fill(this.clone());375 Ok(this)376}377378pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {379 Ok(match object {380 ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,381 ObjBody::ObjComp(obj) => {382 let future_this = FutureWrapper::new();383 let mut builder = ObjValueBuilder::new();384 evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {385 let new_bindings = FutureWrapper::new();386 let context_creator = ContextCreator(context.clone(), new_bindings.clone());387 let mut bindings: FxHashMap<IStr, LazyBinding> =388 FxHashMap::with_capacity_and_hasher(389 obj.pre_locals.len() + obj.post_locals.len(),390 BuildHasherDefault::default(),391 );392 for (n, b) in obj393 .pre_locals394 .iter()395 .chain(obj.post_locals.iter())396 .map(|b| evaluate_binding(b, context_creator.clone()))397 {398 bindings.insert(n, b);399 }400 new_bindings.fill(bindings.clone());401 let ctx = ctx.extend_unbound(bindings, None, None, None)?;402 let key = evaluate(ctx.clone(), &obj.key)?;403404 match key {405 Val::Null => {}406 Val::Str(n) => {407 #[derive(Trace)]408 #[trivially_drop]409 struct ObjCompBinding {410 context: Context,411 value: LocExpr,412 }413 impl Bindable for ObjCompBinding {414 fn bind(415 &self,416 this: Option<ObjValue>,417 _super_obj: Option<ObjValue>,418 ) -> Result<LazyVal> {419 Ok(LazyVal::new_resolved(evaluate(420 self.context.clone().extend(421 FxHashMap::default(),422 None,423 this,424 None,425 ),426 &self.value,427 )?))428 }429 }430 builder431 .member(n)432 .with_location(obj.value.1.clone())433 .bindable(Box::new(ObjCompBinding {434 context: ctx,435 value: obj.value.clone(),436 }));437 }438 v => throw!(FieldMustBeStringGot(v.value_type())),439 }440441 Ok(())442 })?;443444 let this = builder.build();445 future_this.fill(this.clone());446 this447 }448 })449}450451pub fn evaluate_apply(452 context: Context,453 value: &LocExpr,454 args: &ArgsDesc,455 loc: Option<&ExprLocation>,456 tailstrict: bool,457) -> Result<Val> {458 let value = evaluate(context.clone(), value)?;459 Ok(match value {460 Val::Func(f) => {461 let body = || f.evaluate(context, loc, args, tailstrict);462 if tailstrict {463 body()?464 } else {465 push(loc, || format!("function <{}> call", f.name()), body)?466 }467 }468 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),469 })470}471472pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {473 let value = &assertion.0;474 let msg = &assertion.1;475 let assertion_result = push(476 value.1.as_ref(),477 || "assertion condition".to_owned(),478 || {479 evaluate(context.clone(), value)?480 .try_cast_bool("assertion condition should be of type `boolean`")481 },482 )?;483 if !assertion_result {484 push(485 value.1.as_ref(),486 || "assertion failure".to_owned(),487 || {488 if let Some(msg) = msg {489 throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));490 } else {491 throw!(AssertionFailed(Val::Null.to_string()?));492 }493 },494 )?495 }496 Ok(())497}498499pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {500 use Expr::*;501 let LocExpr(expr, _loc) = lexpr;502 Ok(match &**expr {503 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),504 _ => evaluate(context, lexpr)?,505 })506}507508pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {509 use Expr::*;510 let LocExpr(expr, loc) = expr;511 Ok(match &**expr {512 Literal(LiteralType::This) => {513 Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)514 }515 Literal(LiteralType::Super) => Val::Obj(516 context517 .super_obj()518 .clone()519 .ok_or(NoSuperFound)?520 .with_this(context.this().clone().unwrap()),521 ),522 Literal(LiteralType::Dollar) => {523 Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)524 }525 Literal(LiteralType::True) => Val::Bool(true),526 Literal(LiteralType::False) => Val::Bool(false),527 Literal(LiteralType::Null) => Val::Null,528 Parened(e) => evaluate(context, e)?,529 Str(v) => Val::Str(v.clone()),530 Num(v) => Val::new_checked_num(*v)?,531 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,532 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,533 Var(name) => push(534 loc.as_ref(),535 || format!("variable <{}>", name),536 || context.binding(name.clone())?.evaluate(),537 )?,538 Index(value, index) => {539 match (evaluate(context.clone(), value)?, evaluate(context, index)?) {540 (Val::Obj(v), Val::Str(s)) => {541 let sn = s.clone();542 push(543 loc.as_ref(),544 || format!("field <{}> access", sn),545 || {546 if let Some(v) = v.get(s.clone())? {547 Ok(v)548 } else if v.get("__intrinsic_namespace__".into())?.is_some() {549 Ok(Val::Func(Gc::new(FuncVal::Intrinsic(s))))550 } else {551 throw!(NoSuchField(s))552 }553 },554 )?555 }556 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(557 ValType::Obj,558 ValType::Str,559 n.value_type(),560 )),561562 (Val::Arr(v), Val::Num(n)) => {563 if n.fract() > f64::EPSILON {564 throw!(FractionalIndex)565 }566 v.get(n as usize)?567 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?568 }569 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),570 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(571 ValType::Arr,572 ValType::Num,573 n.value_type(),574 )),575576 (Val::Str(s), Val::Num(n)) => Val::Str(577 s.chars()578 .skip(n as usize)579 .take(1)580 .collect::<String>()581 .into(),582 ),583 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(584 ValType::Str,585 ValType::Num,586 n.value_type(),587 )),588589 (v, _) => throw!(CantIndexInto(v.value_type())),590 }591 }592 LocalExpr(bindings, returned) => {593 let mut new_bindings: FxHashMap<IStr, LazyVal> = HashMap::with_capacity_and_hasher(594 bindings.len(),595 BuildHasherDefault::<FxHasher>::default(),596 );597 let future_context = Context::new_future();598 for b in bindings {599 new_bindings.insert(600 b.name.clone(),601 evaluate_binding_in_future(b, future_context.clone()),602 );603 }604 let context = context605 .extend_bound(new_bindings)606 .into_future(future_context);607 evaluate(context, &returned.clone())?608 }609 Arr(items) => {610 let mut out = Vec::with_capacity(items.len());611 for item in items {612 613 #[derive(Trace)]614 #[trivially_drop]615 struct ArrayElement {616 context: Context,617 item: LocExpr,618 }619 impl LazyValValue for ArrayElement {620 fn get(self: Box<Self>) -> Result<Val> {621 evaluate(self.context, &self.item)622 }623 }624 out.push(LazyVal::new(Box::new(ArrayElement {625 context: context.clone(),626 item: item.clone(),627 })));628 }629 Val::Arr(out.into())630 }631 ArrComp(expr, comp_specs) => {632 let mut out = Vec::new();633 evaluate_comp(context, comp_specs, &mut |ctx| {634 out.push(evaluate(ctx, expr)?);635 Ok(())636 })?;637 Val::Arr(ArrValue::Eager(Gc::new(out)))638 }639 Obj(body) => Val::Obj(evaluate_object(context, body)?),640 ObjExtend(s, t) => evaluate_add_op(641 &evaluate(context.clone(), s)?,642 &Val::Obj(evaluate_object(context, t)?),643 )?,644 Apply(value, args, tailstrict) => {645 evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?646 }647 Function(params, body) => {648 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())649 }650 Intrinsic(name) => Val::Func(Gc::new(FuncVal::Intrinsic(name.clone()))),651 AssertExpr(assert, returned) => {652 evaluate_assert(context.clone(), assert)?;653 evaluate(context, returned)?654 }655 ErrorStmt(e) => push(656 loc.as_ref(),657 || "error statement".to_owned(),658 || {659 throw!(RuntimeError(660 evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,661 ))662 },663 )?,664 IfElse {665 cond,666 cond_then,667 cond_else,668 } => {669 if push(670 loc.as_ref(),671 || "if condition".to_owned(),672 || evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),673 )? {674 evaluate(context, cond_then)?675 } else {676 match cond_else {677 Some(v) => evaluate(context, v)?,678 None => Val::Null,679 }680 }681 }682 Import(path) => {683 let tmp = loc684 .clone()685 .expect("imports cannot be used without loc_data")686 .0;687 let mut import_location = tmp.to_path_buf();688 import_location.pop();689 push(690 loc.as_ref(),691 || format!("import {:?}", path),692 || with_state(|s| s.import_file(&import_location, path)),693 )?694 }695 ImportStr(path) => {696 let tmp = loc697 .clone()698 .expect("imports cannot be used without loc_data")699 .0;700 let mut import_location = tmp.to_path_buf();701 import_location.pop();702 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)703 }704 })705}