1use std::{cmp::Ordering, rc::Rc};23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6 ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, FieldName, ForSpecData,7 IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,8};9use jrsonnet_types::ValType;1011use crate::{12 destructure::evaluate_dest,13 error::Error::*,14 evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},15 function::{CallLocation, FuncDesc, FuncVal},16 tb, throw,17 typed::Typed,18 val::{ArrValue, CachedUnbound, IndexableVal, Thunk, ThunkValue},19 Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, State,20 Unbound, Val,21};22pub mod destructure;23pub mod operator;2425pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {26 Val::Func(FuncVal::Normal(Cc::new(FuncDesc {27 name,28 ctx,29 params,30 body,31 })))32}3334pub fn evaluate_field_name(s: State, ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {35 Ok(match field_name {36 FieldName::Fixed(n) => Some(n.clone()),37 FieldName::Dyn(expr) => s.push(38 CallLocation::new(&expr.1),39 || "evaluating field name".to_string(),40 || {41 let value = evaluate(s.clone(), ctx, expr)?;42 if matches!(value, Val::Null) {43 Ok(None)44 } else {45 Ok(Some(IStr::from_untyped(value, s.clone())?))46 }47 },48 )?,49 })50}5152pub fn evaluate_comp(53 s: State,54 ctx: Context,55 specs: &[CompSpec],56 callback: &mut impl FnMut(Context) -> Result<()>,57) -> Result<()> {58 match specs.get(0) {59 None => callback(ctx)?,60 Some(CompSpec::IfSpec(IfSpecData(cond))) => {61 if bool::from_untyped(evaluate(s.clone(), ctx.clone(), cond)?, s.clone())? {62 evaluate_comp(s, ctx, &specs[1..], callback)?;63 }64 }65 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {66 match evaluate(s.clone(), ctx.clone(), expr)? {67 Val::Arr(list) => {68 for item in list.iter(s.clone()) {69 evaluate_comp(70 s.clone(),71 ctx.clone().with_var(var.clone(), item?.clone()),72 &specs[1..],73 callback,74 )?;75 }76 }77 _ => throw!(InComprehensionCanOnlyIterateOverArray),78 }79 }80 }81 Ok(())82}8384trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}8586fn evaluate_object_locals(87 fctx: Pending<Context>,88 locals: Rc<Vec<BindSpec>>,89) -> impl CloneableUnbound<Context> {90 #[derive(Trace, Clone)]91 struct UnboundLocals {92 fctx: Pending<Context>,93 locals: Rc<Vec<BindSpec>>,94 }95 impl CloneableUnbound<Context> for UnboundLocals {}96 impl Unbound for UnboundLocals {97 type Bound = Context;9899 fn bind(100 &self,101 _s: State,102 sup: Option<ObjValue>,103 this: Option<ObjValue>,104 ) -> Result<Context> {105 let fctx = Context::new_future();106 let mut new_bindings = GcHashMap::new();107 for b in self.locals.iter() {108 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;109 }110111 let ctx = self.fctx.unwrap();112 let new_dollar = ctx.dollar().clone().or_else(|| this.clone());113114 let ctx = ctx115 .extend(new_bindings, new_dollar, sup, this)116 .into_future(fctx);117118 Ok(ctx)119 }120 }121122 UnboundLocals { fctx, locals }123}124125#[allow(clippy::too_many_lines)]126pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {127 let mut builder = ObjValueBuilder::new();128 let locals = Rc::new(129 members130 .iter()131 .filter_map(|m| match m {132 Member::BindStmt(bind) => Some(bind.clone()),133 _ => None,134 })135 .collect::<Vec<_>>(),136 );137138 let fctx = Context::new_future();139140 141 let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));142143 for member in members.iter() {144 match member {145 Member::Field(FieldMember {146 name,147 plus,148 params: None,149 visibility,150 value,151 }) => {152 #[derive(Trace)]153 struct UnboundValue<B: Trace> {154 uctx: B,155 value: LocExpr,156 name: IStr,157 }158 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {159 type Bound = Thunk<Val>;160 fn bind(161 &self,162 s: State,163 sup: Option<ObjValue>,164 this: Option<ObjValue>,165 ) -> Result<Thunk<Val>> {166 Ok(Thunk::evaluated(evaluate_named(167 s.clone(),168 self.uctx.bind(s, sup, this)?,169 &self.value,170 self.name.clone(),171 )?))172 }173 }174175 let name = evaluate_field_name(s.clone(), ctx.clone(), name)?;176 let name = if let Some(name) = name {177 name178 } else {179 continue;180 };181182 builder183 .member(name.clone())184 .with_add(*plus)185 .with_visibility(*visibility)186 .with_location(value.1.clone())187 .bindable(188 s.clone(),189 tb!(UnboundValue {190 uctx: uctx.clone(),191 value: value.clone(),192 name: name.clone()193 }),194 )?;195 }196 Member::Field(FieldMember {197 name,198 params: Some(params),199 value,200 ..201 }) => {202 #[derive(Trace)]203 struct UnboundMethod<B: Trace> {204 uctx: B,205 value: LocExpr,206 params: ParamsDesc,207 name: IStr,208 }209 impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {210 type Bound = Thunk<Val>;211 fn bind(212 &self,213 s: State,214 sup: Option<ObjValue>,215 this: Option<ObjValue>,216 ) -> Result<Thunk<Val>> {217 Ok(Thunk::evaluated(evaluate_method(218 self.uctx.bind(s, sup, this)?,219 self.name.clone(),220 self.params.clone(),221 self.value.clone(),222 )))223 }224 }225226 let name = if let Some(name) = evaluate_field_name(s.clone(), ctx.clone(), name)? {227 name228 } else {229 continue;230 };231232 builder233 .member(name.clone())234 .hide()235 .with_location(value.1.clone())236 .bindable(237 s.clone(),238 tb!(UnboundMethod {239 uctx: uctx.clone(),240 value: value.clone(),241 params: params.clone(),242 name: name.clone()243 }),244 )?;245 }246 Member::BindStmt(_) => {}247 Member::AssertStmt(stmt) => {248 #[derive(Trace)]249 struct ObjectAssert<B: Trace> {250 uctx: B,251 assert: AssertStmt,252 }253 impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {254 fn run(255 &self,256 s: State,257 sup: Option<ObjValue>,258 this: Option<ObjValue>,259 ) -> Result<()> {260 let ctx = self.uctx.bind(s.clone(), sup, this)?;261 evaluate_assert(s, ctx, &self.assert)262 }263 }264 builder.assert(tb!(ObjectAssert {265 uctx: uctx.clone(),266 assert: stmt.clone(),267 }));268 }269 }270 }271 let this = builder.build();272 let _ctx = ctx273 .extend(GcHashMap::new(), None, None, Some(this.clone()))274 .into_future(fctx);275 Ok(this)276}277278pub fn evaluate_object(s: State, ctx: Context, object: &ObjBody) -> Result<ObjValue> {279 Ok(match object {280 ObjBody::MemberList(members) => evaluate_member_list_object(s, ctx, members)?,281 ObjBody::ObjComp(obj) => {282 let mut builder = ObjValueBuilder::new();283 let locals = Rc::new(284 obj.pre_locals285 .iter()286 .chain(obj.post_locals.iter())287 .cloned()288 .collect::<Vec<_>>(),289 );290 let mut ctxs = vec![];291 evaluate_comp(s.clone(), ctx, &obj.compspecs, &mut |ctx| {292 let key = evaluate(s.clone(), ctx.clone(), &obj.key)?;293 let fctx = Context::new_future();294 ctxs.push((ctx, fctx.clone()));295 let uctx = evaluate_object_locals(fctx, locals.clone());296297 match key {298 Val::Null => {}299 Val::Str(n) => {300 #[derive(Trace)]301 struct UnboundValue<B: Trace> {302 uctx: B,303 value: LocExpr,304 }305 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {306 type Bound = Thunk<Val>;307 fn bind(308 &self,309 s: State,310 sup: Option<ObjValue>,311 this: Option<ObjValue>,312 ) -> Result<Thunk<Val>> {313 Ok(Thunk::evaluated(evaluate(314 s.clone(),315 self.uctx.bind(s, sup, this.clone())?.extend(316 GcHashMap::new(),317 None,318 None,319 this,320 ),321 &self.value,322 )?))323 }324 }325 builder326 .member(n)327 .with_location(obj.value.1.clone())328 .with_add(obj.plus)329 .bindable(330 s.clone(),331 tb!(UnboundValue {332 uctx,333 value: obj.value.clone(),334 }),335 )?;336 }337 v => throw!(FieldMustBeStringGot(v.value_type())),338 }339340 Ok(())341 })?;342343 let this = builder.build();344 for (ctx, fctx) in ctxs {345 let _ctx = ctx346 .extend(GcHashMap::new(), None, None, Some(this.clone()))347 .into_future(fctx);348 }349 this350 }351 })352}353354pub fn evaluate_apply(355 s: State,356 ctx: Context,357 value: &LocExpr,358 args: &ArgsDesc,359 loc: CallLocation,360 tailstrict: bool,361) -> Result<Val> {362 let value = evaluate(s.clone(), ctx.clone(), value)?;363 Ok(match value {364 Val::Func(f) => {365 let body = || f.evaluate(s.clone(), ctx, loc, args, tailstrict);366 if tailstrict {367 body()?368 } else {369 s.push(loc, || format!("function <{}> call", f.name()), body)?370 }371 }372 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),373 })374}375376pub fn evaluate_assert(s: State, ctx: Context, assertion: &AssertStmt) -> Result<()> {377 let value = &assertion.0;378 let msg = &assertion.1;379 let assertion_result = s.push(380 CallLocation::new(&value.1),381 || "assertion condition".to_owned(),382 || bool::from_untyped(evaluate(s.clone(), ctx.clone(), value)?, s.clone()),383 )?;384 if !assertion_result {385 s.push(386 CallLocation::new(&value.1),387 || "assertion failure".to_owned(),388 || {389 if let Some(msg) = msg {390 throw!(AssertionFailed(391 evaluate(s.clone(), ctx, msg)?.to_string(s.clone())?392 ));393 }394 throw!(AssertionFailed(Val::Null.to_string(s.clone())?));395 },396 )?;397 }398 Ok(())399}400401pub fn evaluate_named(s: State, ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {402 use Expr::*;403 let LocExpr(raw_expr, _loc) = expr;404 Ok(match &**raw_expr {405 Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),406 _ => evaluate(s, ctx, expr)?,407 })408}409410#[allow(clippy::too_many_lines)]411pub fn evaluate(s: State, ctx: Context, expr: &LocExpr) -> Result<Val> {412 use Expr::*;413 let LocExpr(expr, loc) = expr;414 415 Ok(match &**expr {416 Literal(LiteralType::This) => {417 Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)418 }419 Literal(LiteralType::Super) => Val::Obj(420 ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(421 ctx.this()422 .clone()423 .expect("if super exists - then this should to"),424 ),425 ),426 Literal(LiteralType::Dollar) => {427 Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)428 }429 Literal(LiteralType::True) => Val::Bool(true),430 Literal(LiteralType::False) => Val::Bool(false),431 Literal(LiteralType::Null) => Val::Null,432 Parened(e) => evaluate(s, ctx, e)?,433 Str(v) => Val::Str(v.clone()),434 Num(v) => Val::new_checked_num(*v)?,435 BinaryOp(v1, o, v2) => evaluate_binary_op_special(s, ctx, v1, *o, v2)?,436 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(s, ctx, v)?)?,437 Var(name) => s.push(438 CallLocation::new(loc),439 || format!("variable <{}> access", name),440 || ctx.binding(name.clone())?.evaluate(s.clone()),441 )?,442 Index(value, index) => {443 match (444 evaluate(s.clone(), ctx.clone(), value)?,445 evaluate(s.clone(), ctx, index)?,446 ) {447 (Val::Obj(v), Val::Str(key)) => s.push(448 CallLocation::new(loc),449 || format!("field <{}> access", key),450 || match v.get(s.clone(), key.clone()) {451 Ok(Some(v)) => Ok(v),452 #[cfg(not(feature = "friendly-errors"))]453 Ok(None) => throw!(NoSuchField(key.clone(), vec![])),454 #[cfg(feature = "friendly-errors")]455 Ok(None) => {456 let mut heap = Vec::new();457 for field in v.fields_ex(458 true,459 #[cfg(feature = "exp-preserve-order")]460 false,461 ) {462 let conf = strsim::jaro_winkler(&field as &str, &key as &str);463 if conf < 0.8 {464 continue;465 }466 heap.push((conf, field));467 }468 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));469470 throw!(NoSuchField(471 key.clone(),472 heap.into_iter().map(|(_, v)| v).collect()473 ))474 }475 Err(e) => Err(e),476 },477 )?,478 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(479 ValType::Obj,480 ValType::Str,481 n.value_type(),482 )),483484 (Val::Arr(v), Val::Num(n)) => {485 if n.fract() > f64::EPSILON {486 throw!(FractionalIndex)487 }488 v.get(s, n as usize)?489 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?490 }491 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),492 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(493 ValType::Arr,494 ValType::Num,495 n.value_type(),496 )),497498 (Val::Str(s), Val::Num(n)) => Val::Str({499 let v: IStr = s500 .chars()501 .skip(n as usize)502 .take(1)503 .collect::<String>()504 .into();505 if v.is_empty() {506 let size = s.chars().count();507 throw!(StringBoundsError(n as usize, size))508 }509 v510 }),511 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(512 ValType::Str,513 ValType::Num,514 n.value_type(),515 )),516517 (v, _) => throw!(CantIndexInto(v.value_type())),518 }519 }520 LocalExpr(bindings, returned) => {521 let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =522 GcHashMap::with_capacity(bindings.len());523 let fctx = Context::new_future();524 for b in bindings {525 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;526 }527 let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);528 evaluate(s, ctx, &returned.clone())?529 }530 Arr(items) => {531 let mut out = Vec::with_capacity(items.len());532 for item in items {533 534 #[derive(Trace)]535 struct ArrayElement {536 ctx: Context,537 item: LocExpr,538 }539 impl ThunkValue for ArrayElement {540 type Output = Val;541 fn get(self: Box<Self>, s: State) -> Result<Val> {542 evaluate(s, self.ctx, &self.item)543 }544 }545 out.push(Thunk::new(tb!(ArrayElement {546 ctx: ctx.clone(),547 item: item.clone(),548 })));549 }550 Val::Arr(out.into())551 }552 ArrComp(expr, comp_specs) => {553 let mut out = Vec::new();554 evaluate_comp(s.clone(), ctx, comp_specs, &mut |ctx| {555 out.push(evaluate(s.clone(), ctx, expr)?);556 Ok(())557 })?;558 Val::Arr(ArrValue::Eager(Cc::new(out)))559 }560 Obj(body) => Val::Obj(evaluate_object(s, ctx, body)?),561 ObjExtend(a, b) => evaluate_add_op(562 s.clone(),563 &evaluate(s.clone(), ctx.clone(), a)?,564 &Val::Obj(evaluate_object(s, ctx, b)?),565 )?,566 Apply(value, args, tailstrict) => {567 evaluate_apply(s, ctx, value, args, CallLocation::new(loc), *tailstrict)?568 }569 Function(params, body) => {570 evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())571 }572 AssertExpr(assert, returned) => {573 evaluate_assert(s.clone(), ctx.clone(), assert)?;574 evaluate(s, ctx, returned)?575 }576 ErrorStmt(e) => s.push(577 CallLocation::new(loc),578 || "error statement".to_owned(),579 || {580 throw!(RuntimeError(581 evaluate(s.clone(), ctx, e)?.to_string(s.clone())?,582 ))583 },584 )?,585 IfElse {586 cond,587 cond_then,588 cond_else,589 } => {590 if s.push(591 CallLocation::new(loc),592 || "if condition".to_owned(),593 || bool::from_untyped(evaluate(s.clone(), ctx.clone(), &cond.0)?, s.clone()),594 )? {595 evaluate(s, ctx, cond_then)?596 } else {597 match cond_else {598 Some(v) => evaluate(s, ctx, v)?,599 None => Val::Null,600 }601 }602 }603 Slice(value, desc) => {604 fn parse_idx<T: Typed>(605 loc: CallLocation,606 s: State,607 ctx: &Context,608 expr: &Option<LocExpr>,609 desc: &'static str,610 ) -> Result<Option<T>> {611 if let Some(value) = expr {612 Ok(Some(s.push(613 loc,614 || format!("slice {}", desc),615 || T::from_untyped(evaluate(s.clone(), ctx.clone(), value)?, s.clone()),616 )?))617 } else {618 Ok(None)619 }620 }621622 let indexable = evaluate(s.clone(), ctx.clone(), value)?;623 let loc = CallLocation::new(loc);624625 let start = parse_idx(loc, s.clone(), &ctx, &desc.start, "start")?;626 let end = parse_idx(loc, s.clone(), &ctx, &desc.end, "end")?;627 let step = parse_idx(loc, s.clone(), &ctx, &desc.step, "step")?;628629 IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?, s)?630 }631 i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {632 let tmp = loc.clone().0;633 let import_location = tmp634 .path()635 .map(|p| {636 let mut p = p.to_owned();637 p.pop();638 p639 })640 .unwrap_or_default();641 let resolved_path = s.resolve_file(&import_location, path as &str)?;642 match i {643 Import(_) => s.push(644 CallLocation::new(loc),645 || format!("import {:?}", path.clone()),646 || s.import_resolved(resolved_path),647 )?,648 ImportStr(_) => Val::Str(s.import_resolved_str(resolved_path)?),649 ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_resolved_bin(resolved_path)?)),650 _ => unreachable!(),651 }652 }653 })654}