1use crate::{2 builtin::manifest::{3 manifest_json_ex, manifest_yaml_ex, ManifestJsonOptions, ManifestType, ManifestYamlOptions,4 },5 cc_ptr_eq,6 error::{Error::*, LocError},7 evaluate,8 function::{parse_function_call, ArgsLike, Builtin, StaticBuiltin},9 gc::TraceBox,10 throw, Context, ObjValue, Result,11};12use gcmodule::{Cc, Trace};13use jrsonnet_interner::IStr;14use jrsonnet_parser::{ExprLocation, LocExpr, ParamsDesc};15use jrsonnet_types::ValType;16use std::{cell::RefCell, fmt::Debug, rc::Rc};1718pub trait LazyValValue: Trace {19 fn get(self: Box<Self>) -> Result<Val>;20}2122#[derive(Trace)]23enum LazyValInternals {24 Computed(Val),25 Errored(LocError),26 Waiting(TraceBox<dyn LazyValValue>),27 Pending,28}2930#[derive(Clone, Trace)]31pub struct LazyVal(Cc<RefCell<LazyValInternals>>);32impl LazyVal {33 pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {34 Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))35 }36 pub fn new_resolved(val: Val) -> Self {37 Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))38 }39 pub fn force(&self) -> Result<()> {40 self.evaluate()?;41 Ok(())42 }43 pub fn evaluate(&self) -> Result<Val> {44 match &*self.0.borrow() {45 LazyValInternals::Computed(v) => return Ok(v.clone()),46 LazyValInternals::Errored(e) => return Err(e.clone()),47 LazyValInternals::Pending => return Err(RecursiveLazyValueEvaluation.into()),48 _ => (),49 };50 let value = if let LazyValInternals::Waiting(value) =51 std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)52 {53 value54 } else {55 unreachable!()56 };57 let new_value = match value.0.get() {58 Ok(v) => v,59 Err(e) => {60 *self.0.borrow_mut() = LazyValInternals::Errored(e.clone());61 return Err(e);62 }63 };64 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());65 Ok(new_value)66 }67}6869impl Debug for LazyVal {70 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {71 write!(f, "Lazy")72 }73}74impl PartialEq for LazyVal {75 fn eq(&self, other: &Self) -> bool {76 cc_ptr_eq(&self.0, &other.0)77 }78}7980#[derive(Debug, PartialEq, Trace)]81pub struct FuncDesc {82 pub name: IStr,83 pub ctx: Context,84 pub params: ParamsDesc,85 pub body: LocExpr,86}8788#[derive(Trace, Clone)]89pub enum FuncVal {90 91 Normal(Cc<FuncDesc>),92 93 StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),94 95 Builtin(Cc<TraceBox<dyn Builtin>>),96}9798impl Debug for FuncVal {99 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {100 match self {101 Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),102 Self::StaticBuiltin(arg0) => {103 f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()104 }105 Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),106 }107 }108}109110impl PartialEq for FuncVal {111 fn eq(&self, other: &Self) -> bool {112 match (self, other) {113 (Self::Normal(a), Self::Normal(b)) => a == b,114 (Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),115 (..) => false,116 }117 }118}119impl FuncVal {120 pub fn args_len(&self) -> usize {121 match self {122 Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),123 Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),124 Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),125 }126 }127 pub fn name(&self) -> IStr {128 match self {129 Self::Normal(normal) => normal.name.clone(),130 Self::StaticBuiltin(builtin) => builtin.name().into(),131 Self::Builtin(builtin) => builtin.name().into(),132 }133 }134 pub fn evaluate(135 &self,136 call_ctx: Context,137 loc: Option<&ExprLocation>,138 args: &dyn ArgsLike,139 tailstrict: bool,140 ) -> Result<Val> {141 match self {142 Self::Normal(func) => {143 let ctx = parse_function_call(144 call_ctx,145 func.ctx.clone(),146 &func.params,147 args,148 tailstrict,149 )?;150 evaluate(ctx, &func.body)151 }152 Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),153 Self::Builtin(b) => b.call(call_ctx, loc, args),154 }155 }156 pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {157 self.evaluate(Context::default(), None, args, true)158 }159}160161#[derive(Clone)]162pub enum ManifestFormat {163 YamlStream(Box<ManifestFormat>),164 Yaml(usize),165 Json(usize),166 ToString,167 String,168}169170#[derive(Debug, Clone, Trace)]171#[force_tracking]172pub enum ArrValue {173 Lazy(Cc<Vec<LazyVal>>),174 Eager(Cc<Vec<Val>>),175 Extended(Box<(Self, Self)>),176}177impl ArrValue {178 pub fn new_eager() -> Self {179 Self::Eager(Cc::new(Vec::new()))180 }181182 pub fn len(&self) -> usize {183 match self {184 Self::Lazy(l) => l.len(),185 Self::Eager(e) => e.len(),186 Self::Extended(v) => v.0.len() + v.1.len(),187 }188 }189190 pub fn is_empty(&self) -> bool {191 self.len() == 0192 }193194 pub fn get(&self, index: usize) -> Result<Option<Val>> {195 match self {196 Self::Lazy(vec) => {197 if let Some(v) = vec.get(index) {198 Ok(Some(v.evaluate()?))199 } else {200 Ok(None)201 }202 }203 Self::Eager(vec) => Ok(vec.get(index).cloned()),204 Self::Extended(v) => {205 let a_len = v.0.len();206 if a_len > index {207 v.0.get(index)208 } else {209 v.1.get(index - a_len)210 }211 }212 }213 }214215 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {216 match self {217 Self::Lazy(vec) => vec.get(index).cloned(),218 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),219 Self::Extended(v) => {220 let a_len = v.0.len();221 if a_len > index {222 v.0.get_lazy(index)223 } else {224 v.1.get_lazy(index - a_len)225 }226 }227 }228 }229230 pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {231 Ok(match self {232 Self::Lazy(vec) => {233 let mut out = Vec::with_capacity(vec.len());234 for item in vec.iter() {235 out.push(item.evaluate()?);236 }237 Cc::new(out)238 }239 Self::Eager(vec) => vec.clone(),240 Self::Extended(_v) => {241 let mut out = Vec::with_capacity(self.len());242 for item in self.iter() {243 out.push(item?);244 }245 Cc::new(out)246 }247 })248 }249250 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {251 (0..self.len()).map(move |idx| match self {252 Self::Lazy(l) => l[idx].evaluate(),253 Self::Eager(e) => Ok(e[idx].clone()),254 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),255 })256 }257258 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {259 (0..self.len()).map(move |idx| match self {260 Self::Lazy(l) => l[idx].clone(),261 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),262 Self::Extended(_) => self.get_lazy(idx).unwrap(),263 })264 }265266 pub fn reversed(self) -> Self {267 match self {268 Self::Lazy(vec) => {269 let mut out = (&vec as &Vec<_>).clone();270 out.reverse();271 Self::Lazy(Cc::new(out))272 }273 Self::Eager(vec) => {274 let mut out = (&vec as &Vec<_>).clone();275 out.reverse();276 Self::Eager(Cc::new(out))277 }278 Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),279 }280 }281282 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {283 let mut out = Vec::with_capacity(self.len());284285 for value in self.iter() {286 out.push(mapper(value?)?);287 }288289 Ok(Self::Eager(Cc::new(out)))290 }291292 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {293 let mut out = Vec::with_capacity(self.len());294295 for value in self.iter() {296 let value = value?;297 if filter(&value)? {298 out.push(value);299 }300 }301302 Ok(Self::Eager(Cc::new(out)))303 }304305 pub fn ptr_eq(a: &Self, b: &Self) -> bool {306 match (a, b) {307 (Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),308 (Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),309 _ => false,310 }311 }312}313314impl From<Vec<LazyVal>> for ArrValue {315 fn from(v: Vec<LazyVal>) -> Self {316 Self::Lazy(Cc::new(v))317 }318}319320impl From<Vec<Val>> for ArrValue {321 fn from(v: Vec<Val>) -> Self {322 Self::Eager(Cc::new(v))323 }324}325326pub enum IndexableVal {327 Str(IStr),328 Arr(ArrValue),329}330331#[derive(Debug, Clone, Trace)]332pub enum Val {333 Bool(bool),334 Null,335 Str(IStr),336 Num(f64),337 Arr(ArrValue),338 Obj(ObjValue),339 Func(FuncVal),340}341342impl Val {343 pub fn as_bool(&self) -> Option<bool> {344 match self {345 Val::Bool(v) => Some(*v),346 _ => None,347 }348 }349 pub fn as_null(&self) -> Option<()> {350 match self {351 Val::Null => Some(()),352 _ => None,353 }354 }355 pub fn as_str(&self) -> Option<IStr> {356 match self {357 Val::Str(s) => Some(s.clone()),358 _ => None,359 }360 }361 pub fn as_num(&self) -> Option<f64> {362 match self {363 Val::Num(n) => Some(*n),364 _ => None,365 }366 }367 pub fn as_arr(&self) -> Option<ArrValue> {368 match self {369 Val::Arr(a) => Some(a.clone()),370 _ => None,371 }372 }373 pub fn as_obj(&self) -> Option<ObjValue> {374 match self {375 Val::Obj(o) => Some(o.clone()),376 _ => None,377 }378 }379 pub fn as_func(&self) -> Option<FuncVal> {380 match self {381 Val::Func(f) => Some(f.clone()),382 _ => None,383 }384 }385386 387 388 pub fn new_checked_num(num: f64) -> Result<Self> {389 if num.is_finite() {390 Ok(Self::Num(num))391 } else {392 throw!(RuntimeError("overflow".into()))393 }394 }395396 pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {397 Ok(match self {398 Val::Null => None,399 Val::Num(num) => Some(num),400 _ => throw!(TypeMismatch(401 context,402 vec![ValType::Null, ValType::Num],403 self.value_type()404 )),405 })406 }407 pub const fn value_type(&self) -> ValType {408 match self {409 Self::Str(..) => ValType::Str,410 Self::Num(..) => ValType::Num,411 Self::Arr(..) => ValType::Arr,412 Self::Obj(..) => ValType::Obj,413 Self::Bool(_) => ValType::Bool,414 Self::Null => ValType::Null,415 Self::Func(..) => ValType::Func,416 }417 }418419 pub fn to_string(&self) -> Result<IStr> {420 Ok(match self {421 Self::Bool(true) => "true".into(),422 Self::Bool(false) => "false".into(),423 Self::Null => "null".into(),424 Self::Str(s) => s.clone(),425 v => manifest_json_ex(426 v,427 &ManifestJsonOptions {428 padding: "",429 mtype: ManifestType::ToString,430 newline: "\n",431 key_val_sep: ": ",432 },433 )?434 .into(),435 })436 }437438 439 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {440 let obj = match self {441 Self::Obj(obj) => obj,442 _ => throw!(MultiManifestOutputIsNotAObject),443 };444 let keys = obj.fields();445 let mut out = Vec::with_capacity(keys.len());446 for key in keys {447 let value = obj448 .get(key.clone())?449 .expect("item in object")450 .manifest(ty)?;451 out.push((key, value));452 }453 Ok(out)454 }455456 457 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {458 let arr = match self {459 Self::Arr(a) => a,460 _ => throw!(StreamManifestOutputIsNotAArray),461 };462 let mut out = Vec::with_capacity(arr.len());463 for i in arr.iter() {464 out.push(i?.manifest(ty)?);465 }466 Ok(out)467 }468469 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {470 Ok(match ty {471 ManifestFormat::YamlStream(format) => {472 let arr = match self {473 Self::Arr(a) => a,474 _ => throw!(StreamManifestOutputIsNotAArray),475 };476 let mut out = String::new();477478 match format as &ManifestFormat {479 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),480 ManifestFormat::String => throw!(StreamManifestCannotNestString),481 _ => {}482 };483484 if !arr.is_empty() {485 for v in arr.iter() {486 out.push_str("---\n");487 out.push_str(&v?.manifest(format)?);488 out.push('\n');489 }490 out.push_str("...");491 }492493 out.into()494 }495 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,496 ManifestFormat::Json(padding) => self.to_json(*padding)?,497 ManifestFormat::ToString => self.to_string()?,498 ManifestFormat::String => match self {499 Self::Str(s) => s.clone(),500 _ => throw!(StringManifestOutputIsNotAString),501 },502 })503 }504505 506 pub fn to_json(&self, padding: usize) -> Result<IStr> {507 manifest_json_ex(508 self,509 &ManifestJsonOptions {510 padding: &" ".repeat(padding),511 mtype: if padding == 0 {512 ManifestType::Minify513 } else {514 ManifestType::Manifest515 },516 newline: "\n",517 key_val_sep: ": ",518 },519 )520 .map(|s| s.into())521 }522523 524 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {525 manifest_json_ex(526 self,527 &ManifestJsonOptions {528 padding: &" ".repeat(padding),529 mtype: ManifestType::Std,530 newline: "\n",531 key_val_sep: ": ",532 },533 )534 .map(|s| s.into())535 }536537 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {538 let padding = &" ".repeat(padding);539 manifest_yaml_ex(540 self,541 &ManifestYamlOptions {542 padding,543 arr_element_padding: padding,544 quote_keys: false,545 },546 )547 .map(|s| s.into())548 }549 pub fn into_indexable(self) -> Result<IndexableVal> {550 Ok(match self {551 Val::Str(s) => IndexableVal::Str(s),552 Val::Arr(arr) => IndexableVal::Arr(arr),553 _ => throw!(ValueIsNotIndexable(self.value_type())),554 })555 }556}557558const fn is_function_like(val: &Val) -> bool {559 matches!(val, Val::Func(_))560}561562563pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {564 Ok(match (val_a, val_b) {565 (Val::Bool(a), Val::Bool(b)) => a == b,566 (Val::Null, Val::Null) => true,567 (Val::Str(a), Val::Str(b)) => a == b,568 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,569 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(570 "primitiveEquals operates on primitive types, got array".into(),571 )),572 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(573 "primitiveEquals operates on primitive types, got object".into(),574 )),575 (a, b) if is_function_like(a) && is_function_like(b) => {576 throw!(RuntimeError("cannot test equality of functions".into()))577 }578 (_, _) => false,579 })580}581582583pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {584 if val_a.value_type() != val_b.value_type() {585 return Ok(false);586 }587 match (val_a, val_b) {588 (Val::Arr(a), Val::Arr(b)) => {589 if ArrValue::ptr_eq(a, b) {590 return Ok(true);591 }592 if a.len() != b.len() {593 return Ok(false);594 }595 for (a, b) in a.iter().zip(b.iter()) {596 if !equals(&a?, &b?)? {597 return Ok(false);598 }599 }600 Ok(true)601 }602 (Val::Obj(a), Val::Obj(b)) => {603 if ObjValue::ptr_eq(a, b) {604 return Ok(true);605 }606 let fields = a.fields();607 if fields != b.fields() {608 return Ok(false);609 }610 for field in fields {611 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {612 return Ok(false);613 }614 }615 Ok(true)616 }617 (a, b) => Ok(primitive_equals(a, b)?),618 }619}