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 Some(name) = name else {166 continue;167 };168169 builder170 .member(name.clone())171 .with_add(*plus)172 .with_visibility(*visibility)173 .with_location(value.1.clone())174 .bindable(tb!(UnboundValue {175 uctx: uctx.clone(),176 value: value.clone(),177 name: name.clone()178 }))?;179 }180 Member::Field(FieldMember {181 name,182 params: Some(params),183 value,184 ..185 }) => {186 #[derive(Trace)]187 struct UnboundMethod<B: Trace> {188 uctx: B,189 value: LocExpr,190 params: ParamsDesc,191 name: IStr,192 }193 impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {194 type Bound = Thunk<Val>;195 fn bind(196 &self,197 sup: Option<ObjValue>,198 this: Option<ObjValue>,199 ) -> Result<Thunk<Val>> {200 Ok(Thunk::evaluated(evaluate_method(201 self.uctx.bind(sup, this)?,202 self.name.clone(),203 self.params.clone(),204 self.value.clone(),205 )))206 }207 }208209 let name = if let Some(name) = evaluate_field_name(ctx.clone(), name)? {210 name211 } else {212 continue;213 };214215 builder216 .member(name.clone())217 .hide()218 .with_location(value.1.clone())219 .bindable(tb!(UnboundMethod {220 uctx: uctx.clone(),221 value: value.clone(),222 params: params.clone(),223 name: name.clone()224 }))?;225 }226 Member::BindStmt(_) => {}227 Member::AssertStmt(stmt) => {228 #[derive(Trace)]229 struct ObjectAssert<B: Trace> {230 uctx: B,231 assert: AssertStmt,232 }233 impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {234 fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {235 let ctx = self.uctx.bind(sup, this)?;236 evaluate_assert(ctx, &self.assert)237 }238 }239 builder.assert(tb!(ObjectAssert {240 uctx: uctx.clone(),241 assert: stmt.clone(),242 }));243 }244 }245 }246 let this = builder.build();247 fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));248 Ok(this)249}250251pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {252 Ok(match object {253 ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,254 ObjBody::ObjComp(obj) => {255 let mut builder = ObjValueBuilder::new();256 let locals = Rc::new(257 obj.pre_locals258 .iter()259 .chain(obj.post_locals.iter())260 .cloned()261 .collect::<Vec<_>>(),262 );263 let mut ctxs = vec![];264 evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {265 let key = evaluate(ctx.clone(), &obj.key)?;266 let fctx = Context::new_future();267 ctxs.push((ctx, fctx.clone()));268 let uctx = evaluate_object_locals(fctx, locals.clone());269270 match key {271 Val::Null => {}272 Val::Str(n) => {273 #[derive(Trace)]274 struct UnboundValue<B: Trace> {275 uctx: B,276 value: LocExpr,277 }278 impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {279 type Bound = Thunk<Val>;280 fn bind(281 &self,282 sup: Option<ObjValue>,283 this: Option<ObjValue>,284 ) -> Result<Thunk<Val>> {285 Ok(Thunk::evaluated(evaluate(286 self.uctx.bind(sup, this.clone())?.extend(287 GcHashMap::new(),288 None,289 None,290 this,291 ),292 &self.value,293 )?))294 }295 }296 builder297 .member(n)298 .with_location(obj.value.1.clone())299 .with_add(obj.plus)300 .bindable(tb!(UnboundValue {301 uctx,302 value: obj.value.clone(),303 }))?;304 }305 v => throw!(FieldMustBeStringGot(v.value_type())),306 }307308 Ok(())309 })?;310311 let this = builder.build();312 for (ctx, fctx) in ctxs {313 let _ctx = ctx314 .extend(GcHashMap::new(), None, None, Some(this.clone()))315 .into_future(fctx);316 }317 this318 }319 })320}321322pub fn evaluate_apply(323 ctx: Context,324 value: &LocExpr,325 args: &ArgsDesc,326 loc: CallLocation<'_>,327 tailstrict: bool,328) -> Result<Val> {329 let value = evaluate(ctx.clone(), value)?;330 Ok(match value {331 Val::Func(f) => {332 let body = || f.evaluate(ctx, loc, args, tailstrict);333 if tailstrict {334 body()?335 } else {336 State::push(loc, || format!("function <{}> call", f.name()), body)?337 }338 }339 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),340 })341}342343pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {344 let value = &assertion.0;345 let msg = &assertion.1;346 let assertion_result = State::push(347 CallLocation::new(&value.1),348 || "assertion condition".to_owned(),349 || bool::from_untyped(evaluate(ctx.clone(), value)?),350 )?;351 if !assertion_result {352 State::push(353 CallLocation::new(&value.1),354 || "assertion failure".to_owned(),355 || {356 if let Some(msg) = msg {357 throw!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));358 }359 throw!(AssertionFailed(Val::Null.to_string()?));360 },361 )?;362 }363 Ok(())364}365366pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {367 use Expr::*;368 let LocExpr(raw_expr, _loc) = expr;369 Ok(match &**raw_expr {370 Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),371 _ => evaluate(ctx, expr)?,372 })373}374375#[allow(clippy::too_many_lines)]376pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {377 use Expr::*;378 let LocExpr(expr, loc) = expr;379 380 Ok(match &**expr {381 Literal(LiteralType::This) => {382 Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)383 }384 Literal(LiteralType::Super) => Val::Obj(385 ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(386 ctx.this()387 .clone()388 .expect("if super exists - then this should to"),389 ),390 ),391 Literal(LiteralType::Dollar) => {392 Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)393 }394 Literal(LiteralType::True) => Val::Bool(true),395 Literal(LiteralType::False) => Val::Bool(false),396 Literal(LiteralType::Null) => Val::Null,397 Parened(e) => evaluate(ctx, e)?,398 Str(v) => Val::Str(v.clone()),399 Num(v) => Val::new_checked_num(*v)?,400 BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,401 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,402 Var(name) => State::push(403 CallLocation::new(loc),404 || format!("variable <{name}> access"),405 || ctx.binding(name.clone())?.evaluate(),406 )?,407 Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {408 (Val::Obj(v), Val::Str(key)) => State::push(409 CallLocation::new(loc),410 || format!("field <{key}> access"),411 || match v.get(key.clone()) {412 Ok(Some(v)) => Ok(v),413 #[cfg(not(feature = "friendly-errors"))]414 Ok(None) => throw!(NoSuchField(key.clone(), vec![])),415 #[cfg(feature = "friendly-errors")]416 Ok(None) => {417 let mut heap = Vec::new();418 for field in v.fields_ex(419 true,420 #[cfg(feature = "exp-preserve-order")]421 false,422 ) {423 let conf = strsim::jaro_winkler(&field as &str, &key as &str);424 if conf < 0.8 {425 continue;426 }427 heap.push((conf, field));428 }429 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));430431 throw!(NoSuchField(432 key.clone(),433 heap.into_iter().map(|(_, v)| v).collect()434 ))435 }436 Err(e) => Err(e),437 },438 )?,439 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(440 ValType::Obj,441 ValType::Str,442 n.value_type(),443 )),444445 (Val::Arr(v), Val::Num(n)) => {446 if n.fract() > f64::EPSILON {447 throw!(FractionalIndex)448 }449 v.get(n as usize)?450 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?451 }452 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),453 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(454 ValType::Arr,455 ValType::Num,456 n.value_type(),457 )),458459 (Val::Str(s), Val::Num(n)) => Val::Str({460 let v: IStr = s461 .chars()462 .skip(n as usize)463 .take(1)464 .collect::<String>()465 .into();466 if v.is_empty() {467 let size = s.chars().count();468 throw!(StringBoundsError(n as usize, size))469 }470 v471 }),472 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(473 ValType::Str,474 ValType::Num,475 n.value_type(),476 )),477478 (v, _) => throw!(CantIndexInto(v.value_type())),479 },480 LocalExpr(bindings, returned) => {481 let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =482 GcHashMap::with_capacity(bindings.len());483 let fctx = Context::new_future();484 for b in bindings {485 evaluate_dest(b, fctx.clone(), &mut new_bindings)?;486 }487 let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);488 evaluate(ctx, &returned.clone())?489 }490 Arr(items) => {491 let mut out = Vec::with_capacity(items.len());492 for item in items {493 494 #[derive(Trace)]495 struct ArrayElement {496 ctx: Context,497 item: LocExpr,498 }499 impl ThunkValue for ArrayElement {500 type Output = Val;501 fn get(self: Box<Self>) -> Result<Val> {502 evaluate(self.ctx, &self.item)503 }504 }505 out.push(Thunk::new(tb!(ArrayElement {506 ctx: ctx.clone(),507 item: item.clone(),508 })));509 }510 Val::Arr(out.into())511 }512 ArrComp(expr, comp_specs) => {513 let mut out = Vec::new();514 evaluate_comp(ctx, comp_specs, &mut |ctx| {515 out.push(evaluate(ctx, expr)?);516 Ok(())517 })?;518 Val::Arr(ArrValue::Eager(Cc::new(out)))519 }520 Obj(body) => Val::Obj(evaluate_object(ctx, body)?),521 ObjExtend(a, b) => evaluate_add_op(522 &evaluate(ctx.clone(), a)?,523 &Val::Obj(evaluate_object(ctx, b)?),524 )?,525 Apply(value, args, tailstrict) => {526 evaluate_apply(ctx, value, args, CallLocation::new(loc), *tailstrict)?527 }528 Function(params, body) => {529 evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())530 }531 AssertExpr(assert, returned) => {532 evaluate_assert(ctx.clone(), assert)?;533 evaluate(ctx, returned)?534 }535 ErrorStmt(e) => State::push(536 CallLocation::new(loc),537 || "error statement".to_owned(),538 || throw!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),539 )?,540 IfElse {541 cond,542 cond_then,543 cond_else,544 } => {545 if State::push(546 CallLocation::new(loc),547 || "if condition".to_owned(),548 || bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),549 )? {550 evaluate(ctx, cond_then)?551 } else {552 match cond_else {553 Some(v) => evaluate(ctx, v)?,554 None => Val::Null,555 }556 }557 }558 Slice(value, desc) => {559 fn parse_idx<T: Typed>(560 loc: CallLocation<'_>,561 ctx: &Context,562 expr: &Option<LocExpr>,563 desc: &'static str,564 ) -> Result<Option<T>> {565 if let Some(value) = expr {566 Ok(Some(State::push(567 loc,568 || format!("slice {desc}"),569 || T::from_untyped(evaluate(ctx.clone(), value)?),570 )?))571 } else {572 Ok(None)573 }574 }575576 let indexable = evaluate(ctx.clone(), value)?;577 let loc = CallLocation::new(loc);578579 let start = parse_idx(loc, &ctx, &desc.start, "start")?;580 let end = parse_idx(loc, &ctx, &desc.end, "end")?;581 let step = parse_idx(loc, &ctx, &desc.step, "step")?;582583 IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?584 }585 i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {586 let tmp = loc.clone().0;587 let s = ctx.state();588 let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;589 match i {590 Import(_) => State::push(591 CallLocation::new(loc),592 || format!("import {:?}", path.clone()),593 || s.import_resolved(resolved_path),594 )?,595 ImportStr(_) => Val::Str(s.import_resolved_str(resolved_path)?),596 ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_resolved_bin(resolved_path)?)),597 _ => unreachable!(),598 }599 }600 })601}