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(RecursiveLazyValueEvaluation.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)]175#[force_tracking]176pub enum ArrValue {177 Bytes(#[skip_trace] Rc<[u8]>),178 Lazy(Cc<Vec<LazyVal>>),179 Eager(Cc<Vec<Val>>),180 Extended(Box<(Self, Self)>),181}182impl ArrValue {183 pub fn new_eager() -> Self {184 Self::Eager(Cc::new(Vec::new()))185 }186187 pub fn len(&self) -> usize {188 match self {189 Self::Bytes(i) => i.len(),190 Self::Lazy(l) => l.len(),191 Self::Eager(e) => e.len(),192 Self::Extended(v) => v.0.len() + v.1.len(),193 }194 }195196 pub fn is_empty(&self) -> bool {197 self.len() == 0198 }199200 pub fn get(&self, index: usize) -> Result<Option<Val>> {201 match self {202 Self::Bytes(i) => i203 .get(index)204 .map_or(Ok(None), |v| Ok(Some(Val::Num(*v as f64)))),205 Self::Lazy(vec) => {206 if let Some(v) = vec.get(index) {207 Ok(Some(v.evaluate()?))208 } else {209 Ok(None)210 }211 }212 Self::Eager(vec) => Ok(vec.get(index).cloned()),213 Self::Extended(v) => {214 let a_len = v.0.len();215 if a_len > index {216 v.0.get(index)217 } else {218 v.1.get(index - a_len)219 }220 }221 }222 }223224 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {225 match self {226 Self::Bytes(i) => i227 .get(index)228 .map(|b| LazyVal::new_resolved(Val::Num(*b as f64))),229 Self::Lazy(vec) => vec.get(index).cloned(),230 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),231 Self::Extended(v) => {232 let a_len = v.0.len();233 if a_len > index {234 v.0.get_lazy(index)235 } else {236 v.1.get_lazy(index - a_len)237 }238 }239 }240 }241242 pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {243 Ok(match self {244 Self::Bytes(i) => {245 let mut out = Vec::with_capacity(i.len());246 for v in i.iter() {247 out.push(Val::Num(*v as f64));248 }249 Cc::new(out)250 }251 Self::Lazy(vec) => {252 let mut out = Vec::with_capacity(vec.len());253 for item in vec.iter() {254 out.push(item.evaluate()?);255 }256 Cc::new(out)257 }258 Self::Eager(vec) => vec.clone(),259 Self::Extended(_v) => {260 let mut out = Vec::with_capacity(self.len());261 for item in self.iter() {262 out.push(item?);263 }264 Cc::new(out)265 }266 })267 }268269 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {270 (0..self.len()).map(move |idx| match self {271 Self::Bytes(b) => Ok(Val::Num(b[idx] as f64)),272 Self::Lazy(l) => l[idx].evaluate(),273 Self::Eager(e) => Ok(e[idx].clone()),274 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),275 })276 }277278 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {279 (0..self.len()).map(move |idx| match self {280 Self::Bytes(b) => LazyVal::new_resolved(Val::Num(b[idx] as f64)),281 Self::Lazy(l) => l[idx].clone(),282 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),283 Self::Extended(_) => self.get_lazy(idx).unwrap(),284 })285 }286287 pub fn reversed(self) -> Self {288 match self {289 Self::Bytes(b) => {290 let mut out = b.to_vec();291 out.reverse();292 Self::Bytes(out.into())293 }294 Self::Lazy(vec) => {295 let mut out = (&vec as &Vec<_>).clone();296 out.reverse();297 Self::Lazy(Cc::new(out))298 }299 Self::Eager(vec) => {300 let mut out = (&vec as &Vec<_>).clone();301 out.reverse();302 Self::Eager(Cc::new(out))303 }304 Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),305 }306 }307308 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {309 let mut out = Vec::with_capacity(self.len());310311 for value in self.iter() {312 out.push(mapper(value?)?);313 }314315 Ok(Self::Eager(Cc::new(out)))316 }317318 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {319 let mut out = Vec::with_capacity(self.len());320321 for value in self.iter() {322 let value = value?;323 if filter(&value)? {324 out.push(value);325 }326 }327328 Ok(Self::Eager(Cc::new(out)))329 }330331 pub fn ptr_eq(a: &Self, b: &Self) -> bool {332 match (a, b) {333 (Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),334 (Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),335 _ => false,336 }337 }338}339340impl From<Vec<LazyVal>> for ArrValue {341 fn from(v: Vec<LazyVal>) -> Self {342 Self::Lazy(Cc::new(v))343 }344}345346impl From<Vec<Val>> for ArrValue {347 fn from(v: Vec<Val>) -> Self {348 Self::Eager(Cc::new(v))349 }350}351352pub enum IndexableVal {353 Str(IStr),354 Arr(ArrValue),355}356357#[derive(Debug, Clone, Trace)]358pub enum Val {359 Bool(bool),360 Null,361 Str(IStr),362 Num(f64),363 Arr(ArrValue),364 Obj(ObjValue),365 Func(FuncVal),366}367368impl Val {369 pub const fn as_bool(&self) -> Option<bool> {370 match self {371 Val::Bool(v) => Some(*v),372 _ => None,373 }374 }375 pub const fn as_null(&self) -> Option<()> {376 match self {377 Val::Null => Some(()),378 _ => None,379 }380 }381 pub fn as_str(&self) -> Option<IStr> {382 match self {383 Val::Str(s) => Some(s.clone()),384 _ => None,385 }386 }387 pub const fn as_num(&self) -> Option<f64> {388 match self {389 Val::Num(n) => Some(*n),390 _ => None,391 }392 }393 pub fn as_arr(&self) -> Option<ArrValue> {394 match self {395 Val::Arr(a) => Some(a.clone()),396 _ => None,397 }398 }399 pub fn as_obj(&self) -> Option<ObjValue> {400 match self {401 Val::Obj(o) => Some(o.clone()),402 _ => None,403 }404 }405 pub fn as_func(&self) -> Option<FuncVal> {406 match self {407 Val::Func(f) => Some(f.clone()),408 _ => None,409 }410 }411412 413 414 pub fn new_checked_num(num: f64) -> Result<Self> {415 if num.is_finite() {416 Ok(Self::Num(num))417 } else {418 throw!(RuntimeError("overflow".into()))419 }420 }421422 pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {423 Ok(match self {424 Val::Null => None,425 Val::Num(num) => Some(num),426 _ => throw!(TypeMismatch(427 context,428 vec![ValType::Null, ValType::Num],429 self.value_type()430 )),431 })432 }433 pub const fn value_type(&self) -> ValType {434 match self {435 Self::Str(..) => ValType::Str,436 Self::Num(..) => ValType::Num,437 Self::Arr(..) => ValType::Arr,438 Self::Obj(..) => ValType::Obj,439 Self::Bool(_) => ValType::Bool,440 Self::Null => ValType::Null,441 Self::Func(..) => ValType::Func,442 }443 }444445 pub fn to_string(&self) -> Result<IStr> {446 Ok(match self {447 Self::Bool(true) => "true".into(),448 Self::Bool(false) => "false".into(),449 Self::Null => "null".into(),450 Self::Str(s) => s.clone(),451 v => manifest_json_ex(452 v,453 &ManifestJsonOptions {454 padding: "",455 mtype: ManifestType::ToString,456 newline: "\n",457 key_val_sep: ": ",458 },459 )?460 .into(),461 })462 }463464 465 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {466 let obj = match self {467 Self::Obj(obj) => obj,468 _ => throw!(MultiManifestOutputIsNotAObject),469 };470 let keys = obj.fields();471 let mut out = Vec::with_capacity(keys.len());472 for key in keys {473 let value = obj474 .get(key.clone())?475 .expect("item in object")476 .manifest(ty)?;477 out.push((key, value));478 }479 Ok(out)480 }481482 483 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {484 let arr = match self {485 Self::Arr(a) => a,486 _ => throw!(StreamManifestOutputIsNotAArray),487 };488 let mut out = Vec::with_capacity(arr.len());489 for i in arr.iter() {490 out.push(i?.manifest(ty)?);491 }492 Ok(out)493 }494495 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {496 Ok(match ty {497 ManifestFormat::YamlStream(format) => {498 let arr = match self {499 Self::Arr(a) => a,500 _ => throw!(StreamManifestOutputIsNotAArray),501 };502 let mut out = String::new();503504 match format as &ManifestFormat {505 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),506 ManifestFormat::String => throw!(StreamManifestCannotNestString),507 _ => {}508 };509510 if !arr.is_empty() {511 for v in arr.iter() {512 out.push_str("---\n");513 out.push_str(&v?.manifest(format)?);514 out.push('\n');515 }516 out.push_str("...");517 }518519 out.into()520 }521 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,522 ManifestFormat::Json(padding) => self.to_json(*padding)?,523 ManifestFormat::ToString => self.to_string()?,524 ManifestFormat::String => match self {525 Self::Str(s) => s.clone(),526 _ => throw!(StringManifestOutputIsNotAString),527 },528 })529 }530531 532 pub fn to_json(&self, padding: usize) -> Result<IStr> {533 manifest_json_ex(534 self,535 &ManifestJsonOptions {536 padding: &" ".repeat(padding),537 mtype: if padding == 0 {538 ManifestType::Minify539 } else {540 ManifestType::Manifest541 },542 newline: "\n",543 key_val_sep: ": ",544 },545 )546 .map(|s| s.into())547 }548549 550 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {551 manifest_json_ex(552 self,553 &ManifestJsonOptions {554 padding: &" ".repeat(padding),555 mtype: ManifestType::Std,556 newline: "\n",557 key_val_sep: ": ",558 },559 )560 .map(|s| s.into())561 }562563 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {564 let padding = &" ".repeat(padding);565 manifest_yaml_ex(566 self,567 &ManifestYamlOptions {568 padding,569 arr_element_padding: padding,570 quote_keys: false,571 },572 )573 .map(|s| s.into())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}