1use std::convert::TryFrom;23use crate::{4 builtin::{std_slice, BUILTINS},5 error::Error::*,6 evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},7 function::CallLocation,8 gc::TraceBox,9 push_frame, throw, with_state, ArrValue, Bindable, Context, ContextCreator, FuncDesc, FuncVal,10 FutureWrapper, GcHashMap, LazyBinding, LazyVal, LazyValValue, ObjValue, ObjValueBuilder,11 ObjectAssertion, Result, Val,12};13use gcmodule::{Cc, Trace};14use jrsonnet_interner::IStr;15use jrsonnet_parser::{16 ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, ForSpecData, IfSpecData,17 LiteralType, LocExpr, Member, ObjBody, ParamsDesc,18};19use jrsonnet_types::ValType;20pub mod operator;2122pub fn evaluate_binding_in_future(23 b: &BindSpec,24 context_creator: FutureWrapper<Context>,25) -> LazyVal {26 let b = b.clone();27 if let Some(params) = &b.params {28 let params = params.clone();2930 #[derive(Trace)]31 struct LazyMethodBinding {32 context_creator: FutureWrapper<Context>,33 name: IStr,34 params: ParamsDesc,35 value: LocExpr,36 }37 impl LazyValValue for LazyMethodBinding {38 fn get(self: Box<Self>) -> Result<Val> {39 Ok(evaluate_method(40 self.context_creator.unwrap(),41 self.name,42 self.params,43 self.value,44 ))45 }46 }4748 LazyVal::new(TraceBox(Box::new(LazyMethodBinding {49 context_creator,50 name: b.name.clone(),51 params,52 value: b.value.clone(),53 })))54 } else {55 #[derive(Trace)]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(TraceBox(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 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 struct BindableMethod {102 context_creator: ContextCreator,103 name: IStr,104 params: ParamsDesc,105 value: LocExpr,106 }107 impl Bindable for BindableMethod {108 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {109 Ok(LazyVal::new(TraceBox(Box::new(BindableMethodLazyVal {110 this,111 super_obj,112113 context_creator: self.context_creator.clone(),114 name: self.name.clone(),115 params: self.params.clone(),116 value: self.value.clone(),117 }))))118 }119 }120121 (122 b.name.clone(),123 LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableMethod {124 context_creator,125 name: b.name.clone(),126 params,127 value: b.value.clone(),128 })))),129 )130 } else {131 #[derive(Trace)]132 struct BindableNamedLazyVal {133 this: Option<ObjValue>,134 super_obj: Option<ObjValue>,135136 context_creator: ContextCreator,137 name: IStr,138 value: LocExpr,139 }140 impl LazyValValue for BindableNamedLazyVal {141 fn get(self: Box<Self>) -> Result<Val> {142 evaluate_named(143 self.context_creator.create(self.this, self.super_obj)?,144 &self.value,145 self.name,146 )147 }148 }149150 #[derive(Trace)]151 struct BindableNamed {152 context_creator: ContextCreator,153 name: IStr,154 value: LocExpr,155 }156 impl Bindable for BindableNamed {157 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {158 Ok(LazyVal::new(TraceBox(Box::new(BindableNamedLazyVal {159 this,160 super_obj,161162 context_creator: self.context_creator.clone(),163 name: self.name.clone(),164 value: self.value.clone(),165 }))))166 }167 }168169 (170 b.name.clone(),171 LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableNamed {172 context_creator,173 name: b.name.clone(),174 value: b.value.clone(),175 })))),176 )177 }178}179180pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {181 Val::Func(FuncVal::Normal(Cc::new(FuncDesc {182 name,183 ctx,184 params,185 body,186 })))187}188189pub fn evaluate_field_name(190 context: Context,191 field_name: &jrsonnet_parser::FieldName,192) -> Result<Option<IStr>> {193 Ok(match field_name {194 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),195 jrsonnet_parser::FieldName::Dyn(expr) => push_frame(196 CallLocation::new(&expr.1),197 || "evaluating field name".to_string(),198 || {199 let value = evaluate(context, expr)?;200 if matches!(value, Val::Null) {201 Ok(None)202 } else {203 Ok(Some(IStr::try_from(value)?))204 }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 bool::try_from(evaluate(context.clone(), cond)?)? {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: GcHashMap<IStr, LazyBinding> = GcHashMap::with_capacity(members.len());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 struct ObjMemberBinding {275 context_creator: ContextCreator,276 value: LocExpr,277 name: IStr,278 }279 impl Bindable for ObjMemberBinding {280 fn bind(281 &self,282 this: Option<ObjValue>,283 super_obj: Option<ObjValue>,284 ) -> Result<LazyVal> {285 Ok(LazyVal::new_resolved(evaluate_named(286 self.context_creator.create(this, super_obj)?,287 &self.value,288 self.name.clone(),289 )?))290 }291 }292 builder293 .member(name.clone())294 .with_add(*plus)295 .with_visibility(*visibility)296 .with_location(value.1.clone())297 .bindable(TraceBox(Box::new(ObjMemberBinding {298 context_creator: context_creator.clone(),299 value: value.clone(),300 name,301 })));302 }303 Member::Field(FieldMember {304 name,305 params: Some(params),306 value,307 ..308 }) => {309 let name = evaluate_field_name(context.clone(), name)?;310 if name.is_none() {311 continue;312 }313 let name = name.unwrap();314 #[derive(Trace)]315 struct ObjMemberBinding {316 context_creator: ContextCreator,317 value: LocExpr,318 params: ParamsDesc,319 name: IStr,320 }321 impl Bindable for ObjMemberBinding {322 fn bind(323 &self,324 this: Option<ObjValue>,325 super_obj: Option<ObjValue>,326 ) -> Result<LazyVal> {327 Ok(LazyVal::new_resolved(evaluate_method(328 self.context_creator.create(this, super_obj)?,329 self.name.clone(),330 self.params.clone(),331 self.value.clone(),332 )))333 }334 }335 builder336 .member(name.clone())337 .hide()338 .with_location(value.1.clone())339 .bindable(TraceBox(Box::new(ObjMemberBinding {340 context_creator: context_creator.clone(),341 value: value.clone(),342 params: params.clone(),343 name,344 })));345 }346 Member::BindStmt(_) => {}347 Member::AssertStmt(stmt) => {348 #[derive(Trace)]349 struct ObjectAssert {350 context_creator: ContextCreator,351 assert: AssertStmt,352 }353 impl ObjectAssertion for ObjectAssert {354 fn run(355 &self,356 this: Option<ObjValue>,357 super_obj: Option<ObjValue>,358 ) -> Result<()> {359 let ctx = self.context_creator.create(this, super_obj)?;360 evaluate_assert(ctx, &self.assert)361 }362 }363 builder.assert(TraceBox(Box::new(ObjectAssert {364 context_creator: context_creator.clone(),365 assert: stmt.clone(),366 })));367 }368 }369 }370 let this = builder.build();371 future_this.fill(this.clone());372 Ok(this)373}374375pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {376 Ok(match object {377 ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,378 ObjBody::ObjComp(obj) => {379 let future_this = FutureWrapper::new();380 let mut builder = ObjValueBuilder::new();381 evaluate_comp(context.clone(), &obj.compspecs, &mut |ctx| {382 let new_bindings = FutureWrapper::new();383 let context_creator = ContextCreator(context.clone(), new_bindings.clone());384 let mut bindings: GcHashMap<IStr, LazyBinding> =385 GcHashMap::with_capacity(obj.pre_locals.len() + obj.post_locals.len());386 for (n, b) in obj387 .pre_locals388 .iter()389 .chain(obj.post_locals.iter())390 .map(|b| evaluate_binding(b, context_creator.clone()))391 {392 bindings.insert(n, b);393 }394 new_bindings.fill(bindings.clone());395 let ctx = ctx.extend_unbound(bindings, None, None, None)?;396 let key = evaluate(ctx.clone(), &obj.key)?;397398 match key {399 Val::Null => {}400 Val::Str(n) => {401 #[derive(Trace)]402 struct ObjCompBinding {403 context: Context,404 value: LocExpr,405 }406 impl Bindable for ObjCompBinding {407 fn bind(408 &self,409 this: Option<ObjValue>,410 _super_obj: Option<ObjValue>,411 ) -> Result<LazyVal> {412 Ok(LazyVal::new_resolved(evaluate(413 self.context414 .clone()415 .extend(GcHashMap::new(), None, this, None),416 &self.value,417 )?))418 }419 }420 builder421 .member(n)422 .with_location(obj.value.1.clone())423 .with_add(obj.plus)424 .bindable(TraceBox(Box::new(ObjCompBinding {425 context: ctx,426 value: obj.value.clone(),427 })));428 }429 v => throw!(FieldMustBeStringGot(v.value_type())),430 }431432 Ok(())433 })?;434435 let this = builder.build();436 future_this.fill(this.clone());437 this438 }439 })440}441442pub fn evaluate_apply(443 context: Context,444 value: &LocExpr,445 args: &ArgsDesc,446 loc: CallLocation,447 tailstrict: bool,448) -> Result<Val> {449 let value = evaluate(context.clone(), value)?;450 Ok(match value {451 Val::Func(f) => {452 let body = || f.evaluate(context, loc, args, tailstrict);453 if tailstrict {454 body()?455 } else {456 push_frame(loc, || format!("function <{}> call", f.name()), body)?457 }458 }459 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),460 })461}462463pub fn evaluate_assert(context: Context, assertion: &AssertStmt) -> Result<()> {464 let value = &assertion.0;465 let msg = &assertion.1;466 let assertion_result = push_frame(467 CallLocation::new(&value.1),468 || "assertion condition".to_owned(),469 || bool::try_from(evaluate(context.clone(), value)?),470 )?;471 if !assertion_result {472 push_frame(473 CallLocation::new(&value.1),474 || "assertion failure".to_owned(),475 || {476 if let Some(msg) = msg {477 throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));478 } else {479 throw!(AssertionFailed(Val::Null.to_string()?));480 }481 },482 )?483 }484 Ok(())485}486487pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {488 use Expr::*;489 let LocExpr(expr, _loc) = lexpr;490 Ok(match &**expr {491 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),492 _ => evaluate(context, lexpr)?,493 })494}495496pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {497 use Expr::*;498 let LocExpr(expr, loc) = expr;499 500 Ok(match &**expr {501 Literal(LiteralType::This) => {502 Val::Obj(context.this().clone().ok_or(CantUseSelfOutsideOfObject)?)503 }504 Literal(LiteralType::Super) => Val::Obj(505 context506 .super_obj()507 .clone()508 .ok_or(NoSuperFound)?509 .with_this(context.this().clone().unwrap()),510 ),511 Literal(LiteralType::Dollar) => {512 Val::Obj(context.dollar().clone().ok_or(NoTopLevelObjectFound)?)513 }514 Literal(LiteralType::True) => Val::Bool(true),515 Literal(LiteralType::False) => Val::Bool(false),516 Literal(LiteralType::Null) => Val::Null,517 Parened(e) => evaluate(context, e)?,518 Str(v) => Val::Str(v.clone()),519 Num(v) => Val::new_checked_num(*v)?,520 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,521 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,522 Var(name) => push_frame(523 CallLocation::new(loc),524 || format!("variable <{}> access", name),525 || context.binding(name.clone())?.evaluate(),526 )?,527 Index(value, index) => {528 match (evaluate(context.clone(), value)?, evaluate(context, index)?) {529 (Val::Obj(v), Val::Str(s)) => {530 let sn = s.clone();531 push_frame(532 CallLocation::new(loc),533 || format!("field <{}> access", sn),534 || {535 if let Some(v) = v.get(s.clone())? {536 Ok(v)537 } else {538 throw!(NoSuchField(s))539 }540 },541 )?542 }543 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(544 ValType::Obj,545 ValType::Str,546 n.value_type(),547 )),548549 (Val::Arr(v), Val::Num(n)) => {550 if n.fract() > f64::EPSILON {551 throw!(FractionalIndex)552 }553 v.get(n as usize)?554 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?555 }556 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),557 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(558 ValType::Arr,559 ValType::Num,560 n.value_type(),561 )),562563 (Val::Str(s), Val::Num(n)) => Val::Str(564 s.chars()565 .skip(n as usize)566 .take(1)567 .collect::<String>()568 .into(),569 ),570 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(571 ValType::Str,572 ValType::Num,573 n.value_type(),574 )),575576 (v, _) => throw!(CantIndexInto(v.value_type())),577 }578 }579 LocalExpr(bindings, returned) => {580 let mut new_bindings: GcHashMap<IStr, LazyVal> =581 GcHashMap::with_capacity(bindings.len());582 let future_context = Context::new_future();583 for b in bindings {584 new_bindings.insert(585 b.name.clone(),586 evaluate_binding_in_future(b, future_context.clone()),587 );588 }589 let context = context590 .extend_bound(new_bindings)591 .into_future(future_context);592 evaluate(context, &returned.clone())?593 }594 Arr(items) => {595 let mut out = Vec::with_capacity(items.len());596 for item in items {597 598 #[derive(Trace)]599 struct ArrayElement {600 context: Context,601 item: LocExpr,602 }603 impl LazyValValue for ArrayElement {604 fn get(self: Box<Self>) -> Result<Val> {605 evaluate(self.context, &self.item)606 }607 }608 out.push(LazyVal::new(TraceBox(Box::new(ArrayElement {609 context: context.clone(),610 item: item.clone(),611 }))));612 }613 Val::Arr(out.into())614 }615 ArrComp(expr, comp_specs) => {616 let mut out = Vec::new();617 evaluate_comp(context, comp_specs, &mut |ctx| {618 out.push(evaluate(ctx, expr)?);619 Ok(())620 })?;621 Val::Arr(ArrValue::Eager(Cc::new(out)))622 }623 Obj(body) => Val::Obj(evaluate_object(context, body)?),624 ObjExtend(s, t) => evaluate_add_op(625 &evaluate(context.clone(), s)?,626 &Val::Obj(evaluate_object(context, t)?),627 )?,628 Apply(value, args, tailstrict) => {629 evaluate_apply(context, value, args, CallLocation::new(loc), *tailstrict)?630 }631 Function(params, body) => {632 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())633 }634 Intrinsic(name) => Val::Func(FuncVal::StaticBuiltin(635 BUILTINS636 .with(|b| b.get(name).copied())637 .ok_or_else(|| IntrinsicNotFound(name.clone()))?,638 )),639 AssertExpr(assert, returned) => {640 evaluate_assert(context.clone(), assert)?;641 evaluate(context, returned)?642 }643 ErrorStmt(e) => push_frame(644 CallLocation::new(loc),645 || "error statement".to_owned(),646 || throw!(RuntimeError(IStr::try_from(evaluate(context, e)?)?,)),647 )?,648 IfElse {649 cond,650 cond_then,651 cond_else,652 } => {653 if push_frame(654 CallLocation::new(loc),655 || "if condition".to_owned(),656 || bool::try_from(evaluate(context.clone(), &cond.0)?),657 )? {658 evaluate(context, cond_then)?659 } else {660 match cond_else {661 Some(v) => evaluate(context, v)?,662 None => Val::Null,663 }664 }665 }666 Slice(value, desc) => {667 let indexable = evaluate(context.clone(), value)?;668669 fn parse_num(670 context: &Context,671 expr: Option<&LocExpr>,672 desc: &'static str,673 ) -> Result<Option<usize>> {674 Ok(match expr {675 Some(s) => evaluate(context.clone(), s)?676 .try_cast_nullable_num(desc)?677 .map(|v| v as usize),678 None => None,679 })680 }681682 let start = parse_num(&context, desc.start.as_ref(), "start")?;683 let end = parse_num(&context, desc.end.as_ref(), "end")?;684 let step = parse_num(&context, desc.step.as_ref(), "step")?;685686 std_slice(indexable.into_indexable()?, start, end, step)?687 }688 Import(path) => {689 let tmp = loc.clone().0;690 let mut import_location = tmp.to_path_buf();691 import_location.pop();692 push_frame(693 CallLocation::new(loc),694 || format!("import {:?}", path),695 || with_state(|s| s.import_file(&import_location, path)),696 )?697 }698 ImportStr(path) => {699 let tmp = loc.clone().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 ImportBin(path) => {705 let tmp = loc.clone().0;706 let mut import_location = tmp.to_path_buf();707 import_location.pop();708 let bytes = with_state(|s| s.import_file_bin(&import_location, path))?;709 Val::Arr(ArrValue::Bytes(bytes))710 }711 })712}