1use crate::{2 builtin::std_slice,3 error::Error::*,4 evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},5 push, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,6 FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder, ObjectAssertion,7 Result, Val,8};9use jrsonnet_gc::{Gc, Trace};10use jrsonnet_interner::IStr;11use jrsonnet_parser::{12 ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, ExprLocation, FieldMember, ForSpecData,13 IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,14};15use jrsonnet_types::ValType;16use rustc_hash::{FxHashMap, FxHasher};17use std::{collections::HashMap, hash::BuildHasherDefault};18pub mod operator;1920pub fn evaluate_binding_in_future(21 b: &BindSpec,22 context_creator: FutureWrapper<Context>,23) -> LazyVal {24 let b = b.clone();25 if let Some(params) = &b.params {26 let params = params.clone();2728 #[derive(Trace)]29 #[trivially_drop]30 struct LazyMethodBinding {31 context_creator: FutureWrapper<Context>,32 name: IStr,33 params: ParamsDesc,34 value: LocExpr,35 }36 impl LazyValValue for LazyMethodBinding {37 fn get(self: Box<Self>) -> Result<Val> {38 Ok(evaluate_method(39 self.context_creator.unwrap(),40 self.name,41 self.params,42 self.value,43 ))44 }45 }4647 LazyVal::new(Box::new(LazyMethodBinding {48 context_creator,49 name: b.name.clone(),50 params,51 value: b.value.clone(),52 }))53 } else {54 #[derive(Trace)]55 #[trivially_drop]56 struct LazyNamedBinding {57 context_creator: FutureWrapper<Context>,58 name: IStr,59 value: LocExpr,60 }61 impl LazyValValue for LazyNamedBinding {62 fn get(self: Box<Self>) -> Result<Val> {63 evaluate_named(self.context_creator.unwrap(), &self.value, self.name)64 }65 }66 LazyVal::new(Box::new(LazyNamedBinding {67 context_creator,68 name: b.name.clone(),69 value: b.value,70 }))71 }72}7374pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {75 let b = b.clone();76 if let Some(params) = &b.params {77 let params = params.clone();7879 #[derive(Trace)]80 #[trivially_drop]81 struct BindableMethodLazyVal {82 this: Option<ObjValue>,83 super_obj: Option<ObjValue>,8485 context_creator: ContextCreator,86 name: IStr,87 params: ParamsDesc,88 value: LocExpr,89 }90 impl LazyValValue for BindableMethodLazyVal {91 fn get(self: Box<Self>) -> Result<Val> {92 Ok(evaluate_method(93 self.context_creator.create(self.this, self.super_obj)?,94 self.name,95 self.params,96 self.value,97 ))98 }99 }100101 #[derive(Trace)]102 #[trivially_drop]103 struct BindableMethod {104 context_creator: ContextCreator,105 name: IStr,106 params: ParamsDesc,107 value: LocExpr,108 }109 impl Bindable for BindableMethod {110 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {111 Ok(LazyVal::new(Box::new(BindableMethodLazyVal {112 this,113 super_obj,114115 context_creator: self.context_creator.clone(),116 name: self.name.clone(),117 params: self.params.clone(),118 value: self.value.clone(),119 })))120 }121 }122123 (124 b.name.clone(),125 LazyBinding::Bindable(Gc::new(Box::new(BindableMethod {126 context_creator,127 name: b.name.clone(),128 params,129 value: b.value.clone(),130 }))),131 )132 } else {133 #[derive(Trace)]134 #[trivially_drop]135 struct BindableNamedLazyVal {136 this: Option<ObjValue>,137 super_obj: Option<ObjValue>,138139 context_creator: ContextCreator,140 name: IStr,141 value: LocExpr,142 }143 impl LazyValValue for BindableNamedLazyVal {144 fn get(self: Box<Self>) -> Result<Val> {145 evaluate_named(146 self.context_creator.create(self.this, self.super_obj)?,147 &self.value,148 self.name,149 )150 }151 }152153 #[derive(Trace)]154 #[trivially_drop]155 struct BindableNamed {156 context_creator: ContextCreator,157 name: IStr,158 value: LocExpr,159 }160 impl Bindable for BindableNamed {161 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {162 Ok(LazyVal::new(Box::new(BindableNamedLazyVal {163 this,164 super_obj,165166 context_creator: self.context_creator.clone(),167 name: self.name.clone(),168 value: self.value.clone(),169 })))170 }171 }172173 (174 b.name.clone(),175 LazyBinding::Bindable(Gc::new(Box::new(BindableNamed {176 context_creator,177 name: b.name.clone(),178 value: b.value.clone(),179 }))),180 )181 }182}183184pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {185 Val::Func(Gc::new(FuncVal::Normal(FuncDesc {186 name,187 ctx,188 params,189 body,190 })))191}192193pub fn evaluate_field_name(194 context: Context,195 field_name: &jrsonnet_parser::FieldName,196) -> Result<Option<IStr>> {197 Ok(match field_name {198 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),199 jrsonnet_parser::FieldName::Dyn(expr) => {200 let value = evaluate(context, expr)?;201 if matches!(value, Val::Null) {202 None203 } else {204 Some(value.try_cast_str("dynamic field name")?)205 }206 }207 })208}209210pub fn evaluate_comp(211 context: Context,212 specs: &[CompSpec],213 callback: &mut impl FnMut(Context) -> Result<()>,214) -> Result<()> {215 match specs.get(0) {216 None => callback(context)?,217 Some(CompSpec::IfSpec(IfSpecData(cond))) => {218 if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {219 evaluate_comp(context, &specs[1..], callback)?220 }221 }222 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {223 Val::Arr(list) => {224 for item in list.iter() {225 evaluate_comp(226 context.clone().with_var(var.clone(), item?.clone()),227 &specs[1..],228 callback,229 )?230 }231 }232 _ => throw!(InComprehensionCanOnlyIterateOverArray),233 },234 }235 Ok(())236}237238pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {239 let new_bindings = FutureWrapper::new();240 let future_this = FutureWrapper::new();241 let context_creator = ContextCreator(context.clone(), new_bindings.clone());242 {243 let mut bindings: FxHashMap<IStr, LazyBinding> =244 FxHashMap::with_capacity_and_hasher(members.len(), BuildHasherDefault::default());245 for (n, b) in members246 .iter()247 .filter_map(|m| match m {248 Member::BindStmt(b) => Some(b.clone()),249 _ => None,250 })251 .map(|b| evaluate_binding(&b, context_creator.clone()))252 {253 bindings.insert(n, b);254 }255 new_bindings.fill(bindings);256 }257258 let mut builder = ObjValueBuilder::new();259 for member in members.iter() {260 match member {261 Member::Field(FieldMember {262 name,263 plus,264 params: None,265 visibility,266 value,267 }) => {268 let name = evaluate_field_name(context.clone(), name)?;269 if name.is_none() {270 continue;271 }272 let name = name.unwrap();273274 #[derive(Trace)]275 #[trivially_drop]276 struct ObjMemberBinding {277 context_creator: ContextCreator,278 value: LocExpr,279 name: IStr,280 }281 impl Bindable for ObjMemberBinding {282 fn bind(283 &self,284 this: Option<ObjValue>,285 super_obj: Option<ObjValue>,286 ) -> Result<LazyVal> {287 Ok(LazyVal::new_resolved(evaluate_named(288 self.context_creator.create(this, super_obj)?,289 &self.value,290 self.name.clone(),291 )?))292 }293 }294 builder295 .member(name.clone())296 .with_add(*plus)297 .with_visibility(*visibility)298 .with_location(value.1.clone())299 .bindable(Box::new(ObjMemberBinding {300 context_creator: context_creator.clone(),301 value: value.clone(),302 name,303 }));304 }305 Member::Field(FieldMember {306 name,307 params: Some(params),308 value,309 ..310 }) => {311 let name = evaluate_field_name(context.clone(), name)?;312 if name.is_none() {313 continue;314 }315 let name = name.unwrap();316 #[derive(Trace)]317 #[trivially_drop]318 struct ObjMemberBinding {319 context_creator: ContextCreator,320 value: LocExpr,321 params: ParamsDesc,322 name: IStr,323 }324 impl Bindable for ObjMemberBinding {325 fn bind(326 &self,327 this: Option<ObjValue>,328 super_obj: Option<ObjValue>,329 ) -> Result<LazyVal> {330 Ok(LazyVal::new_resolved(evaluate_method(331 self.context_creator.create(this, super_obj)?,332 self.name.clone(),333 self.params.clone(),334 self.value.clone(),335 )))336 }337 }338 builder339 .member(name.clone())340 .hide()341 .with_location(value.1.clone())342 .bindable(Box::new(ObjMemberBinding {343 context_creator: context_creator.clone(),344 value: value.clone(),345 params: params.clone(),346 name,347 }));348 }349 Member::BindStmt(_) => {}350 Member::AssertStmt(stmt) => {351 #[derive(Trace)]352 #[trivially_drop]353 struct ObjectAssert {354 context_creator: ContextCreator,355 assert: AssertStmt,356 }357 impl ObjectAssertion for ObjectAssert {358 fn run(359 &self,360 this: Option<ObjValue>,361 super_obj: Option<ObjValue>,362 ) -> Result<()> {363 let ctx = self.context_creator.create(this, super_obj)?;364 evaluate_assert(ctx, &self.assert)365 }366 }367 builder.assert(Box::new(ObjectAssert {368 context_creator: context_creator.clone(),369 assert: stmt.clone(),370 }));371 }372 }373 }374 let this = builder.build();375 future_this.fill(this.clone());376 Ok(this)377}378379pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {380 Ok(match object {381 ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,382 ObjBody::ObjComp(obj) => {383 let future_this = FutureWrapper::new();384 let mut builder = ObjValueBuilder::new();385 evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {386 let new_bindings = FutureWrapper::new();387 let context_creator = ContextCreator(context.clone(), new_bindings.clone());388 let mut bindings: FxHashMap<IStr, LazyBinding> =389 FxHashMap::with_capacity_and_hasher(390 obj.pre_locals.len() + obj.post_locals.len(),391 BuildHasherDefault::default(),392 );393 for (n, b) in obj394 .pre_locals395 .iter()396 .chain(obj.post_locals.iter())397 .map(|b| evaluate_binding(b, context_creator.clone()))398 {399 bindings.insert(n, b);400 }401 new_bindings.fill(bindings.clone());402 let ctx = ctx.extend_unbound(bindings, None, None, None)?;403 let key = evaluate(ctx.clone(), &obj.key)?;404405 match key {406 Val::Null => {}407 Val::Str(n) => {408 #[derive(Trace)]409 #[trivially_drop]410 struct ObjCompBinding {411 context: Context,412 value: LocExpr,413 }414 impl Bindable for ObjCompBinding {415 fn bind(416 &self,417 this: Option<ObjValue>,418 _super_obj: Option<ObjValue>,419 ) -> Result<LazyVal> {420 Ok(LazyVal::new_resolved(evaluate(421 self.context.clone().extend(422 FxHashMap::default(),423 None,424 this,425 None,426 ),427 &self.value,428 )?))429 }430 }431 builder432 .member(n)433 .with_location(obj.value.1.clone())434 .with_add(obj.plus)435 .bindable(Box::new(ObjCompBinding {436 context: ctx,437 value: obj.value.clone(),438 }));439 }440 v => throw!(FieldMustBeStringGot(v.value_type())),441 }442443 Ok(())444 })?;445446 let this = builder.build();447 future_this.fill(this.clone());448 this449 }450 })451}452453pub fn evaluate_apply(454 context: Context,455 value: &LocExpr,456 args: &ArgsDesc,457 loc: Option<&ExprLocation>,458 tailstrict: bool,459) -> Result<Val> {460 let value = evaluate(context.clone(), value)?;461 Ok(match value {462 Val::Func(f) => {463 let body = || f.evaluate(context, loc, args, tailstrict);464 if tailstrict {465 body()?466 } else {467 push(loc, || format!("function <{}> call", f.name()), body)?468 }469 }470 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),471 })472}473474pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {475 let value = &assertion.0;476 let msg = &assertion.1;477 let assertion_result = push(478 value.1.as_ref(),479 || "assertion condition".to_owned(),480 || {481 evaluate(context.clone(), value)?482 .try_cast_bool("assertion condition should be of type `boolean`")483 },484 )?;485 if !assertion_result {486 push(487 value.1.as_ref(),488 || "assertion failure".to_owned(),489 || {490 if let Some(msg) = msg {491 throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));492 } else {493 throw!(AssertionFailed(Val::Null.to_string()?));494 }495 },496 )?497 }498 Ok(())499}500501pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {502 use Expr::*;503 let LocExpr(expr, _loc) = lexpr;504 Ok(match &**expr {505 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),506 _ => evaluate(context, lexpr)?,507 })508}509510pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {511 use Expr::*;512 let LocExpr(expr, loc) = expr;513 Ok(match &**expr {514 Literal(LiteralType::This) => {515 Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)516 }517 Literal(LiteralType::Super) => Val::Obj(518 context519 .super_obj()520 .clone()521 .ok_or(NoSuperFound)?522 .with_this(context.this().clone().unwrap()),523 ),524 Literal(LiteralType::Dollar) => {525 Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)526 }527 Literal(LiteralType::True) => Val::Bool(true),528 Literal(LiteralType::False) => Val::Bool(false),529 Literal(LiteralType::Null) => Val::Null,530 Parened(e) => evaluate(context, e)?,531 Str(v) => Val::Str(v.clone()),532 Num(v) => Val::new_checked_num(*v)?,533 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,534 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,535 Var(name) => push(536 loc.as_ref(),537 || format!("variable <{}>", name),538 || context.binding(name.clone())?.evaluate(),539 )?,540 Index(value, index) => {541 match (evaluate(context.clone(), value)?, evaluate(context, index)?) {542 (Val::Obj(v), Val::Str(s)) => {543 let sn = s.clone();544 push(545 loc.as_ref(),546 || format!("field <{}> access", sn),547 || {548 if let Some(v) = v.get(s.clone())? {549 Ok(v)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 Slice(value, desc) => {683 let indexable = evaluate(context.clone(), value)?;684685 fn parse_num(686 context: &Context,687 expr: Option<&LocExpr>,688 desc: &'static str,689 ) -> Result<Option<usize>> {690 Ok(match expr {691 Some(s) => evaluate(context.clone(), s)?692 .try_cast_nullable_num(desc)?693 .map(|v| v as usize),694 None => None,695 })696 }697698 let start = parse_num(&context, desc.start.as_ref(), "start")?;699 let end = parse_num(&context, desc.end.as_ref(), "end")?;700 let step = parse_num(&context, desc.step.as_ref(), "step")?;701702 std_slice(indexable.into_indexable()?, start, end, step)?703 }704 Import(path) => {705 let tmp = loc706 .clone()707 .expect("imports cannot be used without loc_data")708 .0;709 let mut import_location = tmp.to_path_buf();710 import_location.pop();711 push(712 loc.as_ref(),713 || format!("import {:?}", path),714 || with_state(|s| s.import_file(&import_location, path)),715 )?716 }717 ImportStr(path) => {718 let tmp = loc719 .clone()720 .expect("imports cannot be used without loc_data")721 .0;722 let mut import_location = tmp.to_path_buf();723 import_location.pop();724 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)725 }726 })727}