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(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {35 Ok(match field_name {36 FieldName::Fixed(n) => Some(n.clone()),37 FieldName::Dyn(expr) => State::push(38 CallLocation::new(&expr.1),39 || "evaluating field name".to_string(),40 || {41 let value = evaluate(ctx, expr)?;42 if matches!(value, Val::Null) {43 Ok(None)44 } else {45 Ok(Some(IStr::from_untyped(value)?))46 }47 },48 )?,49 })50}5152pub fn evaluate_comp(53 ctx: Context,54 specs: &[CompSpec],55 callback: &mut impl FnMut(Context) -> Result<()>,56) -> Result<()> {57 match specs.get(0) {58 None => callback(ctx)?,59 Some(CompSpec::IfSpec(IfSpecData(cond))) => {60 if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {61 evaluate_comp(ctx, &specs[1..], callback)?;62 }63 }64 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {65 Val::Arr(list) => {66 for item in list.iter() {67 evaluate_comp(68 ctx.clone().with_var(var.clone(), item?.clone()),69 &specs[1..],70 callback,71 )?;72 }73 }74 _ => throw!(InComprehensionCanOnlyIterateOverArray),75 },76 }77 Ok(())78}7980trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}8182fn evaluate_object_locals(83 fctx: Pending<Context>,84 locals: Rc<Vec<BindSpec>>,85) -> impl CloneableUnbound<Context> {86 #[derive(Trace, Clone)]87 struct UnboundLocals {88 fctx: Pending<Context>,89 locals: Rc<Vec<BindSpec>>,90 }91 impl CloneableUnbound<Context> for UnboundLocals {}92 impl Unbound for UnboundLocals {93 type Bound = Context;9495 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Context> {96 let fctx = Context::new_future();97 let mut new_bindings = GcHashMap::new();98 for b in self.locals.iter() {99 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;100 }101102 let ctx = self.fctx.unwrap();103 let new_dollar = ctx.dollar().clone().or_else(|| this.clone());104105 let ctx = ctx106 .extend(new_bindings, new_dollar, sup, this)107 .into_future(fctx);108109 Ok(ctx)110 }111 }112113 UnboundLocals { fctx, locals }114}115116#[allow(clippy::too_many_lines)]117pub fn evaluate_member_list_object(ctx: Context, members: &[Member]) -> Result<ObjValue> {118 let mut builder = ObjValueBuilder::new();119 let locals = Rc::new(120 members121 .iter()122 .filter_map(|m| match m {123 Member::BindStmt(bind) => Some(bind.clone()),124 _ => None,125 })126 .collect::<Vec<_>>(),127 );128129 let fctx = Context::new_future();130131 132 let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));133134 for member in members.iter() {135 match member {136 Member::Field(FieldMember {137 name,138 plus,139 params: None,140 visibility,141 value,142 }) => {143 #[derive(Trace)]144 struct UnboundValue<B: Trace> {145 uctx: B,146 value: LocExpr,147 name: IStr,148 }149 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {150 type Bound = Thunk<Val>;151 fn bind(152 &self,153 sup: Option<ObjValue>,154 this: Option<ObjValue>,155 ) -> Result<Thunk<Val>> {156 Ok(Thunk::evaluated(evaluate_named(157 self.uctx.bind(sup, this)?,158 &self.value,159 self.name.clone(),160 )?))161 }162 }163164 let name = evaluate_field_name(ctx.clone(), name)?;165 let name = if let Some(name) = name {166 name167 } else {168 continue;169 };170171 builder172 .member(name.clone())173 .with_add(*plus)174 .with_visibility(*visibility)175 .with_location(value.1.clone())176 .bindable(tb!(UnboundValue {177 uctx: uctx.clone(),178 value: value.clone(),179 name: name.clone()180 }))?;181 }182 Member::Field(FieldMember {183 name,184 params: Some(params),185 value,186 ..187 }) => {188 #[derive(Trace)]189 struct UnboundMethod<B: Trace> {190 uctx: B,191 value: LocExpr,192 params: ParamsDesc,193 name: IStr,194 }195 impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {196 type Bound = Thunk<Val>;197 fn bind(198 &self,199 sup: Option<ObjValue>,200 this: Option<ObjValue>,201 ) -> Result<Thunk<Val>> {202 Ok(Thunk::evaluated(evaluate_method(203 self.uctx.bind(sup, this)?,204 self.name.clone(),205 self.params.clone(),206 self.value.clone(),207 )))208 }209 }210211 let name = if let Some(name) = evaluate_field_name(ctx.clone(), name)? {212 name213 } else {214 continue;215 };216217 builder218 .member(name.clone())219 .hide()220 .with_location(value.1.clone())221 .bindable(tb!(UnboundMethod {222 uctx: uctx.clone(),223 value: value.clone(),224 params: params.clone(),225 name: name.clone()226 }))?;227 }228 Member::BindStmt(_) => {}229 Member::AssertStmt(stmt) => {230 #[derive(Trace)]231 struct ObjectAssert<B: Trace> {232 uctx: B,233 assert: AssertStmt,234 }235 impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {236 fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {237 let ctx = self.uctx.bind(sup, this)?;238 evaluate_assert(ctx, &self.assert)239 }240 }241 builder.assert(tb!(ObjectAssert {242 uctx: uctx.clone(),243 assert: stmt.clone(),244 }));245 }246 }247 }248 let this = builder.build();249 fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));250 Ok(this)251}252253pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {254 Ok(match object {255 ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,256 ObjBody::ObjComp(obj) => {257 let mut builder = ObjValueBuilder::new();258 let locals = Rc::new(259 obj.pre_locals260 .iter()261 .chain(obj.post_locals.iter())262 .cloned()263 .collect::<Vec<_>>(),264 );265 let mut ctxs = vec![];266 evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {267 let key = evaluate(ctx.clone(), &obj.key)?;268 let fctx = Context::new_future();269 ctxs.push((ctx, fctx.clone()));270 let uctx = evaluate_object_locals(fctx, locals.clone());271272 match key {273 Val::Null => {}274 Val::Str(n) => {275 #[derive(Trace)]276 struct UnboundValue<B: Trace> {277 uctx: B,278 value: LocExpr,279 }280 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {281 type Bound = Thunk<Val>;282 fn bind(283 &self,284 sup: Option<ObjValue>,285 this: Option<ObjValue>,286 ) -> Result<Thunk<Val>> {287 Ok(Thunk::evaluated(evaluate(288 self.uctx.bind(sup, this.clone())?.extend(289 GcHashMap::new(),290 None,291 None,292 this,293 ),294 &self.value,295 )?))296 }297 }298 builder299 .member(n)300 .with_location(obj.value.1.clone())301 .with_add(obj.plus)302 .bindable(tb!(UnboundValue {303 uctx,304 value: obj.value.clone(),305 }))?;306 }307 v => throw!(FieldMustBeStringGot(v.value_type())),308 }309310 Ok(())311 })?;312313 let this = builder.build();314 for (ctx, fctx) in ctxs {315 let _ctx = ctx316 .extend(GcHashMap::new(), None, None, Some(this.clone()))317 .into_future(fctx);318 }319 this320 }321 })322}323324pub fn evaluate_apply(325 ctx: Context,326 value: &LocExpr,327 args: &ArgsDesc,328 loc: CallLocation<'_>,329 tailstrict: bool,330) -> Result<Val> {331 let value = evaluate(ctx.clone(), value)?;332 Ok(match value {333 Val::Func(f) => {334 let body = || f.evaluate(ctx, loc, args, tailstrict);335 if tailstrict {336 body()?337 } else {338 State::push(loc, || format!("function <{}> call", f.name()), body)?339 }340 }341 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),342 })343}344345pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {346 let value = &assertion.0;347 let msg = &assertion.1;348 let assertion_result = State::push(349 CallLocation::new(&value.1),350 || "assertion condition".to_owned(),351 || bool::from_untyped(evaluate(ctx.clone(), value)?),352 )?;353 if !assertion_result {354 State::push(355 CallLocation::new(&value.1),356 || "assertion failure".to_owned(),357 || {358 if let Some(msg) = msg {359 throw!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));360 }361 throw!(AssertionFailed(Val::Null.to_string()?));362 },363 )?;364 }365 Ok(())366}367368pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {369 use Expr::*;370 let LocExpr(raw_expr, _loc) = expr;371 Ok(match &**raw_expr {372 Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),373 _ => evaluate(ctx, expr)?,374 })375}376377#[allow(clippy::too_many_lines)]378pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {379 use Expr::*;380 let LocExpr(expr, loc) = expr;381 382 Ok(match &**expr {383 Literal(LiteralType::This) => {384 Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)385 }386 Literal(LiteralType::Super) => Val::Obj(387 ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(388 ctx.this()389 .clone()390 .expect("if super exists - then this should to"),391 ),392 ),393 Literal(LiteralType::Dollar) => {394 Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)395 }396 Literal(LiteralType::True) => Val::Bool(true),397 Literal(LiteralType::False) => Val::Bool(false),398 Literal(LiteralType::Null) => Val::Null,399 Parened(e) => evaluate(ctx, e)?,400 Str(v) => Val::Str(v.clone()),401 Num(v) => Val::new_checked_num(*v)?,402 BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,403 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,404 Var(name) => State::push(405 CallLocation::new(loc),406 || format!("variable <{name}> access"),407 || ctx.binding(name.clone())?.evaluate(),408 )?,409 Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {410 (Val::Obj(v), Val::Str(key)) => State::push(411 CallLocation::new(loc),412 || format!("field <{key}> access"),413 || match v.get(key.clone()) {414 Ok(Some(v)) => Ok(v),415 #[cfg(not(feature = "friendly-errors"))]416 Ok(None) => throw!(NoSuchField(key.clone(), vec![])),417 #[cfg(feature = "friendly-errors")]418 Ok(None) => {419 let mut heap = Vec::new();420 for field in v.fields_ex(421 true,422 #[cfg(feature = "exp-preserve-order")]423 false,424 ) {425 let conf = strsim::jaro_winkler(&field as &str, &key as &str);426 if conf < 0.8 {427 continue;428 }429 heap.push((conf, field));430 }431 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));432433 throw!(NoSuchField(434 key.clone(),435 heap.into_iter().map(|(_, v)| v).collect()436 ))437 }438 Err(e) => Err(e),439 },440 )?,441 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(442 ValType::Obj,443 ValType::Str,444 n.value_type(),445 )),446447 (Val::Arr(v), Val::Num(n)) => {448 if n.fract() > f64::EPSILON {449 throw!(FractionalIndex)450 }451 v.get(n as usize)?452 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?453 }454 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),455 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(456 ValType::Arr,457 ValType::Num,458 n.value_type(),459 )),460461 (Val::Str(s), Val::Num(n)) => Val::Str({462 let v: IStr = s463 .chars()464 .skip(n as usize)465 .take(1)466 .collect::<String>()467 .into();468 if v.is_empty() {469 let size = s.chars().count();470 throw!(StringBoundsError(n as usize, size))471 }472 v473 }),474 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(475 ValType::Str,476 ValType::Num,477 n.value_type(),478 )),479480 (v, _) => throw!(CantIndexInto(v.value_type())),481 },482 LocalExpr(bindings, returned) => {483 let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =484 GcHashMap::with_capacity(bindings.len());485 let fctx = Context::new_future();486 for b in bindings {487 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;488 }489 let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);490 evaluate(ctx, &returned.clone())?491 }492 Arr(items) => {493 let mut out = Vec::with_capacity(items.len());494 for item in items {495 496 #[derive(Trace)]497 struct ArrayElement {498 ctx: Context,499 item: LocExpr,500 }501 impl ThunkValue for ArrayElement {502 type Output = Val;503 fn get(self: Box<Self>) -> Result<Val> {504 evaluate(self.ctx, &self.item)505 }506 }507 out.push(Thunk::new(tb!(ArrayElement {508 ctx: ctx.clone(),509 item: item.clone(),510 })));511 }512 Val::Arr(out.into())513 }514 ArrComp(expr, comp_specs) => {515 let mut out = Vec::new();516 evaluate_comp(ctx, comp_specs, &mut |ctx| {517 out.push(evaluate(ctx, expr)?);518 Ok(())519 })?;520 Val::Arr(ArrValue::Eager(Cc::new(out)))521 }522 Obj(body) => Val::Obj(evaluate_object(ctx, body)?),523 ObjExtend(a, b) => evaluate_add_op(524 &evaluate(ctx.clone(), a)?,525 &Val::Obj(evaluate_object(ctx, b)?),526 )?,527 Apply(value, args, tailstrict) => {528 evaluate_apply(ctx, value, args, CallLocation::new(loc), *tailstrict)?529 }530 Function(params, body) => {531 evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())532 }533 AssertExpr(assert, returned) => {534 evaluate_assert(ctx.clone(), assert)?;535 evaluate(ctx, returned)?536 }537 ErrorStmt(e) => State::push(538 CallLocation::new(loc),539 || "error statement".to_owned(),540 || throw!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),541 )?,542 IfElse {543 cond,544 cond_then,545 cond_else,546 } => {547 if State::push(548 CallLocation::new(loc),549 || "if condition".to_owned(),550 || bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),551 )? {552 evaluate(ctx, cond_then)?553 } else {554 match cond_else {555 Some(v) => evaluate(ctx, v)?,556 None => Val::Null,557 }558 }559 }560 Slice(value, desc) => {561 fn parse_idx<T: Typed>(562 loc: CallLocation<'_>,563 ctx: &Context,564 expr: &Option<LocExpr>,565 desc: &'static str,566 ) -> Result<Option<T>> {567 if let Some(value) = expr {568 Ok(Some(State::push(569 loc,570 || format!("slice {desc}"),571 || T::from_untyped(evaluate(ctx.clone(), value)?),572 )?))573 } else {574 Ok(None)575 }576 }577578 let indexable = evaluate(ctx.clone(), value)?;579 let loc = CallLocation::new(loc);580581 let start = parse_idx(loc, &ctx, &desc.start, "start")?;582 let end = parse_idx(loc, &ctx, &desc.end, "end")?;583 let step = parse_idx(loc, &ctx, &desc.step, "step")?;584585 IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?586 }587 i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {588 let tmp = loc.clone().0;589 let s = ctx.state();590 let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;591 match i {592 Import(_) => State::push(593 CallLocation::new(loc),594 || format!("import {:?}", path.clone()),595 || s.import_resolved(resolved_path),596 )?,597 ImportStr(_) => Val::Str(s.import_resolved_str(resolved_path)?),598 ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_resolved_bin(resolved_path)?)),599 _ => unreachable!(),600 }601 }602 })603}