1use crate::{2 builtin::{3 call_builtin,4 manifest::{manifest_json_ex, ManifestJsonOptions, ManifestType},5 },6 error::{Error::*, LocError},7 evaluate,8 function::{parse_function_call, parse_function_call_map, place_args},9 native::NativeCallback,10 throw, with_state, Context, ObjValue, Result,11};12use jrsonnet_gc::{Gc, GcCell, Trace};13use jrsonnet_interner::IStr;14use jrsonnet_parser::{el, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};15use jrsonnet_types::ValType;16use std::{collections::HashMap, fmt::Debug, rc::Rc};1718pub trait LazyValValue: Trace {19 fn get(self: Box<Self>) -> Result<Val>;20}2122#[derive(Trace)]23#[trivially_drop]24enum LazyValInternals {25 Computed(Val),26 Errored(LocError),27 Waiting(Box<dyn LazyValValue>),28 Pending,29}3031#[derive(Clone, Trace)]32#[trivially_drop]33pub struct LazyVal(Gc<GcCell<LazyValInternals>>);34impl LazyVal {35 pub fn new(f: Box<dyn LazyValValue>) -> Self {36 Self(Gc::new(GcCell::new(LazyValInternals::Waiting(f))))37 }38 pub fn new_resolved(val: Val) -> Self {39 Self(Gc::new(GcCell::new(LazyValInternals::Computed(val))))40 }41 pub fn evaluate(&self) -> Result<Val> {42 match &*self.0.borrow() {43 LazyValInternals::Computed(v) => return Ok(v.clone()),44 LazyValInternals::Errored(e) => return Err(e.clone()),45 LazyValInternals::Pending => return Err(RecursiveLazyValueEvaluation.into()),46 _ => (),47 };48 let value = if let LazyValInternals::Waiting(value) =49 std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)50 {51 value52 } else {53 unreachable!()54 };55 let new_value = match value.get() {56 Ok(v) => v,57 Err(e) => {58 *self.0.borrow_mut() = LazyValInternals::Errored(e.clone());59 return Err(e);60 }61 };62 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());63 Ok(new_value)64 }65}6667impl Debug for LazyVal {68 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {69 write!(f, "Lazy")70 }71}72impl PartialEq for LazyVal {73 fn eq(&self, other: &Self) -> bool {74 Gc::ptr_eq(&self.0, &other.0)75 }76}7778#[derive(Debug, PartialEq, Trace)]79#[trivially_drop]80pub struct FuncDesc {81 pub name: IStr,82 pub ctx: Context,83 pub params: ParamsDesc,84 pub body: LocExpr,85}8687#[derive(Debug, Trace)]88#[trivially_drop]89pub enum FuncVal {90 91 Normal(FuncDesc),92 93 Intrinsic(IStr),94 95 NativeExt(IStr, Gc<NativeCallback>),96}9798impl PartialEq for FuncVal {99 fn eq(&self, other: &Self) -> bool {100 match (self, other) {101 (Self::Normal(a), Self::Normal(b)) => a == b,102 (Self::Intrinsic(an), Self::Intrinsic(bn)) => an == bn,103 (Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,104 (..) => false,105 }106 }107}108impl FuncVal {109 pub fn is_ident(&self) -> bool {110 matches!(&self, Self::Intrinsic(n) if n as &str == "id")111 }112 pub fn name(&self) -> IStr {113 match self {114 Self::Normal(normal) => normal.name.clone(),115 Self::Intrinsic(name) => format!("std.{}", name).into(),116 Self::NativeExt(n, _) => format!("native.{}", n).into(),117 }118 }119 pub fn evaluate(120 &self,121 call_ctx: Context,122 loc: Option<&ExprLocation>,123 args: &ArgsDesc,124 tailstrict: bool,125 ) -> Result<Val> {126 match self {127 Self::Normal(func) => {128 let ctx = parse_function_call(129 call_ctx,130 func.ctx.clone(),131 &func.params,132 args,133 tailstrict,134 )?;135 evaluate(ctx, &func.body)136 }137 Self::Intrinsic(name) => call_builtin(call_ctx, loc, name, args),138 Self::NativeExt(_name, handler) => {139 let args =140 parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;141 let mut out_args = Vec::with_capacity(handler.params.len());142 for p in handler.params.0.iter() {143 out_args.push(args.binding(p.0.clone())?.evaluate()?);144 }145 Ok(handler.call(loc.map(|l| l.0.clone()), &out_args)?)146 }147 }148 }149150 pub fn evaluate_map(151 &self,152 call_ctx: Context,153 args: &HashMap<IStr, Val>,154 tailstrict: bool,155 ) -> Result<Val> {156 match self {157 Self::Normal(func) => {158 let ctx = parse_function_call_map(159 call_ctx,160 Some(func.ctx.clone()),161 &func.params,162 args,163 tailstrict,164 )?;165 evaluate(ctx, &func.body)166 }167 Self::Intrinsic(_) => todo!(),168 Self::NativeExt(_, _) => todo!(),169 }170 }171172 pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {173 match self {174 Self::Normal(func) => {175 let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;176 evaluate(ctx, &func.body)177 }178 Self::Intrinsic(_) => todo!(),179 Self::NativeExt(_, _) => todo!(),180 }181 }182}183184#[derive(Clone)]185pub enum ManifestFormat {186 YamlStream(Box<ManifestFormat>),187 Yaml(usize),188 Json(usize),189 ToString,190 String,191}192193#[derive(Debug, Clone, Trace)]194#[trivially_drop]195pub enum ArrValue {196 Lazy(Gc<Vec<LazyVal>>),197 Eager(Gc<Vec<Val>>),198 Extended(Box<(Self, Self)>),199}200impl ArrValue {201 pub fn new_eager() -> Self {202 Self::Eager(Gc::new(Vec::new()))203 }204205 pub fn len(&self) -> usize {206 match self {207 Self::Lazy(l) => l.len(),208 Self::Eager(e) => e.len(),209 Self::Extended(v) => v.0.len() + v.1.len(),210 }211 }212213 pub fn is_empty(&self) -> bool {214 self.len() == 0215 }216217 pub fn get(&self, index: usize) -> Result<Option<Val>> {218 match self {219 Self::Lazy(vec) => {220 if let Some(v) = vec.get(index) {221 Ok(Some(v.evaluate()?))222 } else {223 Ok(None)224 }225 }226 Self::Eager(vec) => Ok(vec.get(index).cloned()),227 Self::Extended(v) => {228 let a_len = v.0.len();229 if a_len > index {230 v.0.get(index)231 } else {232 v.1.get(index - a_len)233 }234 }235 }236 }237238 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {239 match self {240 Self::Lazy(vec) => vec.get(index).cloned(),241 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),242 Self::Extended(v) => {243 let a_len = v.0.len();244 if a_len > index {245 v.0.get_lazy(index)246 } else {247 v.1.get_lazy(index - a_len)248 }249 }250 }251 }252253 pub fn evaluated(&self) -> Result<Gc<Vec<Val>>> {254 Ok(match self {255 Self::Lazy(vec) => {256 let mut out = Vec::with_capacity(vec.len());257 for item in vec.iter() {258 out.push(item.evaluate()?);259 }260 Gc::new(out)261 }262 Self::Eager(vec) => vec.clone(),263 Self::Extended(_v) => {264 let mut out = Vec::with_capacity(self.len());265 for item in self.iter() {266 out.push(item?);267 }268 Gc::new(out)269 }270 })271 }272273 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {274 (0..self.len()).map(move |idx| match self {275 Self::Lazy(l) => l[idx].evaluate(),276 Self::Eager(e) => Ok(e[idx].clone()),277 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),278 })279 }280281 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {282 (0..self.len()).map(move |idx| match self {283 Self::Lazy(l) => l[idx].clone(),284 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),285 Self::Extended(_) => self.get_lazy(idx).unwrap(),286 })287 }288289 pub fn reversed(self) -> Self {290 match self {291 Self::Lazy(vec) => {292 let mut out = (&vec as &Vec<_>).clone();293 out.reverse();294 Self::Lazy(Gc::new(out))295 }296 Self::Eager(vec) => {297 let mut out = (&vec as &Vec<_>).clone();298 out.reverse();299 Self::Eager(Gc::new(out))300 }301 Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),302 }303 }304305 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {306 let mut out = Vec::with_capacity(self.len());307308 for value in self.iter() {309 out.push(mapper(value?)?);310 }311312 Ok(Self::Eager(Gc::new(out)))313 }314315 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {316 let mut out = Vec::with_capacity(self.len());317318 for value in self.iter() {319 let value = value?;320 if filter(&value)? {321 out.push(value);322 }323 }324325 Ok(Self::Eager(Gc::new(out)))326 }327328 pub fn ptr_eq(a: &Self, b: &Self) -> bool {329 match (a, b) {330 (Self::Lazy(a), Self::Lazy(b)) => Gc::ptr_eq(a, b),331 (Self::Eager(a), Self::Eager(b)) => Gc::ptr_eq(a, b),332 _ => false,333 }334 }335}336337impl From<Vec<LazyVal>> for ArrValue {338 fn from(v: Vec<LazyVal>) -> Self {339 Self::Lazy(Gc::new(v))340 }341}342343impl From<Vec<Val>> for ArrValue {344 fn from(v: Vec<Val>) -> Self {345 Self::Eager(Gc::new(v))346 }347}348349pub enum IndexableVal {350 Str(IStr),351 Arr(ArrValue),352}353354#[derive(Debug, Clone, Trace)]355#[trivially_drop]356pub enum Val {357 Bool(bool),358 Null,359 Str(IStr),360 Num(f64),361 Arr(ArrValue),362 Obj(ObjValue),363 Func(Gc<FuncVal>),364}365366macro_rules! matches_unwrap {367 ($e: expr, $p: pat, $r: expr) => {368 match $e {369 $p => $r,370 _ => panic!("no match"),371 }372 };373}374impl Val {375 376 377 pub fn new_checked_num(num: f64) -> Result<Self> {378 if num.is_finite() {379 Ok(Self::Num(num))380 } else {381 throw!(RuntimeError("overflow".into()))382 }383 }384385 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {386 let this_type = self.value_type();387 if this_type != val_type {388 throw!(TypeMismatch(context, vec![val_type], this_type))389 } else {390 Ok(())391 }392 }393 pub fn unwrap_num(self) -> Result<f64> {394 Ok(matches_unwrap!(self, Self::Num(v), v))395 }396 pub fn unwrap_func(self) -> Result<Gc<FuncVal>> {397 Ok(matches_unwrap!(self, Self::Func(v), v))398 }399 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {400 self.assert_type(context, ValType::Bool)?;401 Ok(matches_unwrap!(self, Self::Bool(v), v))402 }403 pub fn try_cast_str(self, context: &'static str) -> Result<IStr> {404 self.assert_type(context, ValType::Str)?;405 Ok(matches_unwrap!(self, Self::Str(v), v))406 }407 pub fn try_cast_num(self, context: &'static str) -> Result<f64> {408 self.assert_type(context, ValType::Num)?;409 self.unwrap_num()410 }411 pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {412 Ok(match self {413 Val::Null => None,414 Val::Num(num) => Some(num),415 _ => throw!(TypeMismatch(416 context,417 vec![ValType::Null, ValType::Num],418 self.value_type()419 )),420 })421 }422 pub const fn value_type(&self) -> ValType {423 match self {424 Self::Str(..) => ValType::Str,425 Self::Num(..) => ValType::Num,426 Self::Arr(..) => ValType::Arr,427 Self::Obj(..) => ValType::Obj,428 Self::Bool(_) => ValType::Bool,429 Self::Null => ValType::Null,430 Self::Func(..) => ValType::Func,431 }432 }433434 pub fn to_string(&self) -> Result<IStr> {435 Ok(match self {436 Self::Bool(true) => "true".into(),437 Self::Bool(false) => "false".into(),438 Self::Null => "null".into(),439 Self::Str(s) => s.clone(),440 v => manifest_json_ex(441 v,442 &ManifestJsonOptions {443 padding: "",444 mtype: ManifestType::ToString,445 },446 )?447 .into(),448 })449 }450451 452 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {453 let obj = match self {454 Self::Obj(obj) => obj,455 _ => throw!(MultiManifestOutputIsNotAObject),456 };457 let keys = obj.fields();458 let mut out = Vec::with_capacity(keys.len());459 for key in keys {460 let value = obj461 .get(key.clone())?462 .expect("item in object")463 .manifest(ty)?;464 out.push((key, value));465 }466 Ok(out)467 }468469 470 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {471 let arr = match self {472 Self::Arr(a) => a,473 _ => throw!(StreamManifestOutputIsNotAArray),474 };475 let mut out = Vec::with_capacity(arr.len());476 for i in arr.iter() {477 out.push(i?.manifest(ty)?);478 }479 Ok(out)480 }481482 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {483 Ok(match ty {484 ManifestFormat::YamlStream(format) => {485 let arr = match self {486 Self::Arr(a) => a,487 _ => throw!(StreamManifestOutputIsNotAArray),488 };489 let mut out = String::new();490491 match format as &ManifestFormat {492 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),493 ManifestFormat::String => throw!(StreamManifestCannotNestString),494 _ => {}495 };496497 if !arr.is_empty() {498 for v in arr.iter() {499 out.push_str("---\n");500 out.push_str(&v?.manifest(format)?);501 out.push('\n');502 }503 out.push_str("...");504 }505506 out.into()507 }508 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,509 ManifestFormat::Json(padding) => self.to_json(*padding)?,510 ManifestFormat::ToString => self.to_string()?,511 ManifestFormat::String => match self {512 Self::Str(s) => s.clone(),513 _ => throw!(StringManifestOutputIsNotAString),514 },515 })516 }517518 519 pub fn to_json(&self, padding: usize) -> Result<IStr> {520 manifest_json_ex(521 self,522 &ManifestJsonOptions {523 padding: &" ".repeat(padding),524 mtype: if padding == 0 {525 ManifestType::Minify526 } else {527 ManifestType::Manifest528 },529 },530 )531 .map(|s| s.into())532 }533534 535 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {536 manifest_json_ex(537 self,538 &ManifestJsonOptions {539 padding: &" ".repeat(padding),540 mtype: ManifestType::Std,541 },542 )543 .map(|s| s.into())544 }545546 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {547 with_state(|s| {548 let ctx = s549 .create_default_context()550 .with_var("__tmp__to_json__".into(), self.clone());551 evaluate(552 ctx,553 &el!(Expr::Apply(554 el!(Expr::Index(555 el!(Expr::Var("std".into())),556 el!(Expr::Str("manifestYamlDoc".into()))557 )),558 ArgsDesc::new(559 vec![560 el!(Expr::Var("__tmp__to_json__".into())),561 el!(Expr::Literal(if padding != 0 {562 LiteralType::True563 } else {564 LiteralType::False565 })),566 ],567 vec![]568 ),569 false570 )),571 )?572 .try_cast_str("to json")573 })574 }575 pub fn into_indexable(self) -> Result<IndexableVal> {576 Ok(match self {577 Val::Str(s) => IndexableVal::Str(s),578 Val::Arr(arr) => IndexableVal::Arr(arr),579 _ => throw!(ValueIsNotIndexable(self.value_type())),580 })581 }582}583584const fn is_function_like(val: &Val) -> bool {585 matches!(val, Val::Func(_))586}587588589pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {590 Ok(match (val_a, val_b) {591 (Val::Bool(a), Val::Bool(b)) => a == b,592 (Val::Null, Val::Null) => true,593 (Val::Str(a), Val::Str(b)) => a == b,594 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,595 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(596 "primitiveEquals operates on primitive types, got array".into(),597 )),598 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(599 "primitiveEquals operates on primitive types, got object".into(),600 )),601 (a, b) if is_function_like(a) && is_function_like(b) => {602 throw!(RuntimeError("cannot test equality of functions".into()))603 }604 (_, _) => false,605 })606}607608609pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {610 if val_a.value_type() != val_b.value_type() {611 return Ok(false);612 }613 match (val_a, val_b) {614 (Val::Arr(a), Val::Arr(b)) => {615 if ArrValue::ptr_eq(a, b) {616 return Ok(true);617 }618 if a.len() != b.len() {619 return Ok(false);620 }621 for (a, b) in a.iter().zip(b.iter()) {622 if !equals(&a?, &b?)? {623 return Ok(false);624 }625 }626 Ok(true)627 }628 (Val::Obj(a), Val::Obj(b)) => {629 if ObjValue::ptr_eq(a, b) {630 return Ok(true);631 }632 let fields = a.fields();633 if fields != b.fields() {634 return Ok(false);635 }636 for field in fields {637 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {638 return Ok(false);639 }640 }641 Ok(true)642 }643 (a, b) => Ok(primitive_equals(a, b)?),644 }645}