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::{9 parse_default_function_call, parse_function_call, ArgsLike, Builtin, CallLocation,10 StaticBuiltin,11 },12 gc::TraceBox,13 throw, Context, ObjValue, Result,14};15use gcmodule::{Cc, Trace};16use jrsonnet_interner::IStr;17use jrsonnet_parser::{LocExpr, ParamsDesc};18use jrsonnet_types::ValType;19use std::{cell::RefCell, fmt::Debug, rc::Rc};2021pub trait LazyValValue: Trace {22 fn get(self: Box<Self>) -> Result<Val>;23}2425#[derive(Trace)]26enum LazyValInternals {27 Computed(Val),28 Errored(LocError),29 Waiting(TraceBox<dyn LazyValValue>),30 Pending,31}3233#[derive(Clone, Trace)]34pub struct LazyVal(Cc<RefCell<LazyValInternals>>);35impl LazyVal {36 pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {37 Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))38 }39 pub fn new_resolved(val: Val) -> Self {40 Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))41 }42 pub fn force(&self) -> Result<()> {43 self.evaluate()?;44 Ok(())45 }46 pub fn evaluate(&self) -> Result<Val> {47 match &*self.0.borrow() {48 LazyValInternals::Computed(v) => return Ok(v.clone()),49 LazyValInternals::Errored(e) => return Err(e.clone()),50 LazyValInternals::Pending => return Err(InfiniteRecursionDetected.into()),51 _ => (),52 };53 let value = if let LazyValInternals::Waiting(value) =54 std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)55 {56 value57 } else {58 unreachable!()59 };60 let new_value = match value.0.get() {61 Ok(v) => v,62 Err(e) => {63 *self.0.borrow_mut() = LazyValInternals::Errored(e.clone());64 return Err(e);65 }66 };67 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());68 Ok(new_value)69 }70}7172impl Debug for LazyVal {73 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {74 write!(f, "Lazy")75 }76}77impl PartialEq for LazyVal {78 fn eq(&self, other: &Self) -> bool {79 cc_ptr_eq(&self.0, &other.0)80 }81}8283#[derive(Debug, PartialEq, Trace)]84pub struct FuncDesc {85 pub name: IStr,86 pub ctx: Context,87 pub params: ParamsDesc,88 pub body: LocExpr,89}90impl FuncDesc {91 92 pub fn default_body_context(&self) -> Context {93 parse_default_function_call(self.ctx.clone(), &self.params)94 }9596 97 pub fn call_body_context(98 &self,99 call_ctx: Context,100 args: &dyn ArgsLike,101 tailstrict: bool,102 ) -> Result<Context> {103 parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)104 }105}106107#[derive(Trace, Clone)]108pub enum FuncVal {109 110 Normal(Cc<FuncDesc>),111 112 StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),113 114 Builtin(Cc<TraceBox<dyn Builtin>>),115}116117impl Debug for FuncVal {118 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {119 match self {120 Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),121 Self::StaticBuiltin(arg0) => {122 f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()123 }124 Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),125 }126 }127}128129impl FuncVal {130 pub fn args_len(&self) -> usize {131 match self {132 Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),133 Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),134 Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),135 }136 }137 pub fn name(&self) -> IStr {138 match self {139 Self::Normal(normal) => normal.name.clone(),140 Self::StaticBuiltin(builtin) => builtin.name().into(),141 Self::Builtin(builtin) => builtin.name().into(),142 }143 }144 pub fn evaluate(145 &self,146 call_ctx: Context,147 loc: CallLocation,148 args: &dyn ArgsLike,149 tailstrict: bool,150 ) -> Result<Val> {151 match self {152 Self::Normal(func) => {153 let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;154 evaluate(body_ctx, &func.body)155 }156 Self::StaticBuiltin(b) => b.call(call_ctx, loc, args),157 Self::Builtin(b) => b.call(call_ctx, loc, args),158 }159 }160 pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {161 self.evaluate(Context::default(), CallLocation::native(), args, true)162 }163}164165#[derive(Clone)]166pub enum ManifestFormat {167 YamlStream(Box<ManifestFormat>),168 Yaml(usize),169 Json(usize),170 ToString,171 String,172}173174#[derive(Debug, Clone, Trace)]175pub struct Slice {176 pub(crate) inner: ArrValue,177 pub(crate) from: u32,178 pub(crate) to: u32,179 pub(crate) step: u32,180}181impl Slice {182 fn from(&self) -> usize {183 self.from as usize184 }185 fn to(&self) -> usize {186 self.to as usize187 }188 fn step(&self) -> usize {189 self.step as usize190 }191 fn len(&self) -> usize {192 193 let diff = self.to() - self.from();194 let rem = diff % self.step();195 let div = diff / self.step();196197 if rem != 0 {198 div + 1199 } else {200 div201 }202 }203}204205#[derive(Debug, Clone, Trace)]206#[force_tracking]207pub enum ArrValue {208 Bytes(#[skip_trace] Rc<[u8]>),209 Lazy(Cc<Vec<LazyVal>>),210 Eager(Cc<Vec<Val>>),211 Extended(Box<(Self, Self)>),212 Range(i32, i32),213 Slice(Box<Slice>),214 Reversed(Box<Self>),215}216impl ArrValue {217 pub fn new_eager() -> Self {218 Self::Eager(Cc::new(Vec::new()))219 }220 pub fn new_range(a: i32, b: i32) -> Self {221 assert!(a <= b);222 Self::Range(a, b)223 }224225 pub fn slice(self, from: Option<usize>, to: Option<usize>, step: Option<usize>) -> Self {226 let len = self.len();227 let from = from.unwrap_or(0);228 let to = to.unwrap_or(len).min(len);229 let step = step.unwrap_or(1);230 assert!(from < to);231 assert!(step > 0);232233 Self::Slice(Box::new(Slice {234 inner: self,235 from: from as u32,236 to: to as u32,237 step: step as u32,238 }))239 }240241 pub fn len(&self) -> usize {242 match self {243 Self::Bytes(i) => i.len(),244 Self::Lazy(l) => l.len(),245 Self::Eager(e) => e.len(),246 Self::Extended(v) => v.0.len() + v.1.len(),247 Self::Range(a, b) => a.abs_diff(*b) as usize,248 Self::Reversed(i) => i.len(),249 Self::Slice(s) => s.len(),250 }251 }252253 pub fn is_empty(&self) -> bool {254 self.len() == 0255 }256257 pub fn get(&self, index: usize) -> Result<Option<Val>> {258 match self {259 Self::Bytes(i) => i260 .get(index)261 .map_or(Ok(None), |v| Ok(Some(Val::Num(*v as f64)))),262 Self::Lazy(vec) => {263 if let Some(v) = vec.get(index) {264 Ok(Some(v.evaluate()?))265 } else {266 Ok(None)267 }268 }269 Self::Eager(vec) => Ok(vec.get(index).cloned()),270 Self::Extended(v) => {271 let a_len = v.0.len();272 if a_len > index {273 v.0.get(index)274 } else {275 v.1.get(index - a_len)276 }277 }278 Self::Range(a, _) => {279 if index >= self.len() {280 return Ok(None);281 }282 Ok(Some(Val::Num(((*a as isize) + index as isize) as f64)))283 }284 Self::Reversed(v) => {285 let len = v.len();286 if index >= len {287 return Ok(None);288 }289 v.get(len - index - 1)290 }291 Self::Slice(s) => {292 let index = s.from() + index * s.step();293 if index >= s.to() {294 return Ok(None);295 }296 s.inner.get(index as usize)297 }298 }299 }300301 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {302 match self {303 Self::Bytes(i) => i304 .get(index)305 .map(|b| LazyVal::new_resolved(Val::Num(*b as f64))),306 Self::Lazy(vec) => vec.get(index).cloned(),307 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),308 Self::Extended(v) => {309 let a_len = v.0.len();310 if a_len > index {311 v.0.get_lazy(index)312 } else {313 v.1.get_lazy(index - a_len)314 }315 }316 Self::Range(a, _) => {317 if index >= self.len() {318 return None;319 }320 Some(LazyVal::new_resolved(Val::Num(321 ((*a as isize) + index as isize) as f64,322 )))323 }324 Self::Reversed(v) => {325 let len = v.len();326 if index >= len {327 return None;328 }329 v.get_lazy(len - index - 1)330 }331 Self::Slice(s) => {332 let index = s.from() + index * s.step();333 if index >= s.to() {334 return None;335 }336 s.inner.get_lazy(index as usize)337 }338 }339 }340341 pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {342 Ok(match self {343 Self::Bytes(i) => {344 let mut out = Vec::with_capacity(i.len());345 for v in i.iter() {346 out.push(Val::Num(*v as f64));347 }348 Cc::new(out)349 }350 Self::Lazy(vec) => {351 let mut out = Vec::with_capacity(vec.len());352 for item in vec.iter() {353 out.push(item.evaluate()?);354 }355 Cc::new(out)356 }357 Self::Eager(vec) => vec.clone(),358 Self::Extended(_v) => {359 let mut out = Vec::with_capacity(self.len());360 for item in self.iter() {361 out.push(item?);362 }363 Cc::new(out)364 }365 Self::Range(a, b) => {366 let mut out = Vec::with_capacity(self.len());367 for i in *a..*b {368 out.push(Val::Num(i as f64));369 }370 Cc::new(out)371 }372 Self::Reversed(r) => {373 let mut r = r.evaluated()?;374 Cc::update_with(&mut r, |v| v.reverse());375 r376 }377 Self::Slice(v) => {378 let mut out = Vec::with_capacity(v.inner.len());379 for v in v380 .inner381 .iter_lazy()382 .skip(v.from())383 .take(v.to() - v.from())384 .step_by(v.step())385 {386 out.push(v.evaluate()?)387 }388 Cc::new(out)389 }390 })391 }392393 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {394 (0..self.len()).map(move |idx| match self {395 Self::Bytes(b) => Ok(Val::Num(b[idx] as f64)),396 Self::Lazy(l) => l[idx].evaluate(),397 Self::Eager(e) => Ok(e[idx].clone()),398 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),399 Self::Range(..) => self.get(idx).map(|e| e.unwrap()),400 Self::Reversed(..) => self.get(idx).map(|e| e.unwrap()),401 Self::Slice(..) => self.get(idx).map(|e| e.unwrap()),402 })403 }404405 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {406 (0..self.len()).map(move |idx| match self {407 Self::Bytes(b) => LazyVal::new_resolved(Val::Num(b[idx] as f64)),408 Self::Lazy(l) => l[idx].clone(),409 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),410 Self::Extended(_) => self.get_lazy(idx).unwrap(),411 Self::Range(..) => self.get_lazy(idx).unwrap(),412 Self::Reversed(..) => self.get_lazy(idx).unwrap(),413 Self::Slice(..) => self.get_lazy(idx).unwrap(),414 })415 }416417 pub fn reversed(self) -> Self {418 Self::Reversed(Box::new(self))419 }420421 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {422 let mut out = Vec::with_capacity(self.len());423424 for value in self.iter() {425 out.push(mapper(value?)?);426 }427428 Ok(Self::Eager(Cc::new(out)))429 }430431 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {432 let mut out = Vec::with_capacity(self.len());433434 for value in self.iter() {435 let value = value?;436 if filter(&value)? {437 out.push(value);438 }439 }440441 Ok(Self::Eager(Cc::new(out)))442 }443444 pub fn ptr_eq(a: &Self, b: &Self) -> bool {445 match (a, b) {446 (Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),447 (Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),448 _ => false,449 }450 }451}452453impl From<Vec<LazyVal>> for ArrValue {454 fn from(v: Vec<LazyVal>) -> Self {455 Self::Lazy(Cc::new(v))456 }457}458459impl From<Vec<Val>> for ArrValue {460 fn from(v: Vec<Val>) -> Self {461 Self::Eager(Cc::new(v))462 }463}464465pub enum IndexableVal {466 Str(IStr),467 Arr(ArrValue),468}469470#[derive(Debug, Clone, Trace)]471pub enum Val {472 Bool(bool),473 Null,474 Str(IStr),475 Num(f64),476 Arr(ArrValue),477 Obj(ObjValue),478 Func(FuncVal),479}480481impl Val {482 pub const fn as_bool(&self) -> Option<bool> {483 match self {484 Val::Bool(v) => Some(*v),485 _ => None,486 }487 }488 pub const fn as_null(&self) -> Option<()> {489 match self {490 Val::Null => Some(()),491 _ => None,492 }493 }494 pub fn as_str(&self) -> Option<IStr> {495 match self {496 Val::Str(s) => Some(s.clone()),497 _ => None,498 }499 }500 pub const fn as_num(&self) -> Option<f64> {501 match self {502 Val::Num(n) => Some(*n),503 _ => None,504 }505 }506 pub fn as_arr(&self) -> Option<ArrValue> {507 match self {508 Val::Arr(a) => Some(a.clone()),509 _ => None,510 }511 }512 pub fn as_obj(&self) -> Option<ObjValue> {513 match self {514 Val::Obj(o) => Some(o.clone()),515 _ => None,516 }517 }518 pub fn as_func(&self) -> Option<FuncVal> {519 match self {520 Val::Func(f) => Some(f.clone()),521 _ => None,522 }523 }524525 526 527 pub fn new_checked_num(num: f64) -> Result<Self> {528 if num.is_finite() {529 Ok(Self::Num(num))530 } else {531 throw!(RuntimeError("overflow".into()))532 }533 }534535 pub const fn value_type(&self) -> ValType {536 match self {537 Self::Str(..) => ValType::Str,538 Self::Num(..) => ValType::Num,539 Self::Arr(..) => ValType::Arr,540 Self::Obj(..) => ValType::Obj,541 Self::Bool(_) => ValType::Bool,542 Self::Null => ValType::Null,543 Self::Func(..) => ValType::Func,544 }545 }546547 pub fn to_string(&self) -> Result<IStr> {548 Ok(match self {549 Self::Bool(true) => "true".into(),550 Self::Bool(false) => "false".into(),551 Self::Null => "null".into(),552 Self::Str(s) => s.clone(),553 v => manifest_json_ex(554 v,555 &ManifestJsonOptions {556 padding: "",557 mtype: ManifestType::ToString,558 newline: "\n",559 key_val_sep: ": ",560 },561 )?562 .into(),563 })564 }565566 567 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {568 let obj = match self {569 Self::Obj(obj) => obj,570 _ => throw!(MultiManifestOutputIsNotAObject),571 };572 let keys = obj.fields();573 let mut out = Vec::with_capacity(keys.len());574 for key in keys {575 let value = obj576 .get(key.clone())?577 .expect("item in object")578 .manifest(ty)?;579 out.push((key, value));580 }581 Ok(out)582 }583584 585 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {586 let arr = match self {587 Self::Arr(a) => a,588 _ => throw!(StreamManifestOutputIsNotAArray),589 };590 let mut out = Vec::with_capacity(arr.len());591 for i in arr.iter() {592 out.push(i?.manifest(ty)?);593 }594 Ok(out)595 }596597 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {598 Ok(match ty {599 ManifestFormat::YamlStream(format) => {600 let arr = match self {601 Self::Arr(a) => a,602 _ => throw!(StreamManifestOutputIsNotAArray),603 };604 let mut out = String::new();605606 match format as &ManifestFormat {607 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),608 ManifestFormat::String => throw!(StreamManifestCannotNestString),609 _ => {}610 };611612 if !arr.is_empty() {613 for v in arr.iter() {614 out.push_str("---\n");615 out.push_str(&v?.manifest(format)?);616 out.push('\n');617 }618 out.push_str("...");619 }620621 out.into()622 }623 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,624 ManifestFormat::Json(padding) => self.to_json(*padding)?,625 ManifestFormat::ToString => self.to_string()?,626 ManifestFormat::String => match self {627 Self::Str(s) => s.clone(),628 _ => throw!(StringManifestOutputIsNotAString),629 },630 })631 }632633 634 pub fn to_json(&self, padding: usize) -> Result<IStr> {635 manifest_json_ex(636 self,637 &ManifestJsonOptions {638 padding: &" ".repeat(padding),639 mtype: if padding == 0 {640 ManifestType::Minify641 } else {642 ManifestType::Manifest643 },644 newline: "\n",645 key_val_sep: ": ",646 },647 )648 .map(|s| s.into())649 }650651 652 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {653 manifest_json_ex(654 self,655 &ManifestJsonOptions {656 padding: &" ".repeat(padding),657 mtype: ManifestType::Std,658 newline: "\n",659 key_val_sep: ": ",660 },661 )662 .map(|s| s.into())663 }664665 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {666 let padding = &" ".repeat(padding);667 manifest_yaml_ex(668 self,669 &ManifestYamlOptions {670 padding,671 arr_element_padding: padding,672 quote_keys: false,673 },674 )675 .map(|s| s.into())676 }677 pub fn into_indexable(self) -> Result<IndexableVal> {678 Ok(match self {679 Val::Str(s) => IndexableVal::Str(s),680 Val::Arr(arr) => IndexableVal::Arr(arr),681 _ => throw!(ValueIsNotIndexable(self.value_type())),682 })683 }684}685686const fn is_function_like(val: &Val) -> bool {687 matches!(val, Val::Func(_))688}689690691pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {692 Ok(match (val_a, val_b) {693 (Val::Bool(a), Val::Bool(b)) => a == b,694 (Val::Null, Val::Null) => true,695 (Val::Str(a), Val::Str(b)) => a == b,696 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,697 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(698 "primitiveEquals operates on primitive types, got array".into(),699 )),700 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(701 "primitiveEquals operates on primitive types, got object".into(),702 )),703 (a, b) if is_function_like(a) && is_function_like(b) => {704 throw!(RuntimeError("cannot test equality of functions".into()))705 }706 (_, _) => false,707 })708}709710711pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {712 if val_a.value_type() != val_b.value_type() {713 return Ok(false);714 }715 match (val_a, val_b) {716 (Val::Arr(a), Val::Arr(b)) => {717 if ArrValue::ptr_eq(a, b) {718 return Ok(true);719 }720 if a.len() != b.len() {721 return Ok(false);722 }723 for (a, b) in a.iter().zip(b.iter()) {724 if !equals(&a?, &b?)? {725 return Ok(false);726 }727 }728 Ok(true)729 }730 (Val::Obj(a), Val::Obj(b)) => {731 if ObjValue::ptr_eq(a, b) {732 return Ok(true);733 }734 let fields = a.fields();735 if fields != b.fields() {736 return Ok(false);737 }738 for field in fields {739 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {740 return Ok(false);741 }742 }743 Ok(true)744 }745 (a, b) => Ok(primitive_equals(a, b)?),746 }747}