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),9495 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) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),103 Self::Builtin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),104 }105 }106}107108impl PartialEq for FuncVal {109 fn eq(&self, other: &Self) -> bool {110 match (self, other) {111 (Self::Normal(a), Self::Normal(b)) => a == b,112 (Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),113 (..) => false,114 }115 }116}117impl FuncVal {118 pub fn args_len(&self) -> usize {119 match self {120 Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),121 Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),122 Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),123 }124 }125 pub fn name(&self) -> IStr {126 match self {127 Self::Normal(normal) => normal.name.clone(),128 Self::StaticBuiltin(builtin) => builtin.name().into(),129 Self::Builtin(builtin) => builtin.name().into(),130 }131 }132 pub fn evaluate(133 &self,134 call_ctx: Context,135 loc: Option<&ExprLocation>,136 args: &dyn ArgsLike,137 tailstrict: bool,138 ) -> Result<Val> {139 match self {140 Self::Normal(func) => {141 let ctx = parse_function_call(142 call_ctx,143 func.ctx.clone(),144 &func.params,145 args,146 tailstrict,147 )?;148 evaluate(ctx, &func.body)149 }150 Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),151 Self::Builtin(b) => b.call(call_ctx, loc, args),152 }153 }154 pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {155 self.evaluate(Context::default(), None, args, true)156 }157}158159#[derive(Clone)]160pub enum ManifestFormat {161 YamlStream(Box<ManifestFormat>),162 Yaml(usize),163 Json(usize),164 ToString,165 String,166}167168#[derive(Debug, Clone, Trace)]169#[force_tracking]170pub enum ArrValue {171 Lazy(Cc<Vec<LazyVal>>),172 Eager(Cc<Vec<Val>>),173 Extended(Box<(Self, Self)>),174}175impl ArrValue {176 pub fn new_eager() -> Self {177 Self::Eager(Cc::new(Vec::new()))178 }179180 pub fn len(&self) -> usize {181 match self {182 Self::Lazy(l) => l.len(),183 Self::Eager(e) => e.len(),184 Self::Extended(v) => v.0.len() + v.1.len(),185 }186 }187188 pub fn is_empty(&self) -> bool {189 self.len() == 0190 }191192 pub fn get(&self, index: usize) -> Result<Option<Val>> {193 match self {194 Self::Lazy(vec) => {195 if let Some(v) = vec.get(index) {196 Ok(Some(v.evaluate()?))197 } else {198 Ok(None)199 }200 }201 Self::Eager(vec) => Ok(vec.get(index).cloned()),202 Self::Extended(v) => {203 let a_len = v.0.len();204 if a_len > index {205 v.0.get(index)206 } else {207 v.1.get(index - a_len)208 }209 }210 }211 }212213 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {214 match self {215 Self::Lazy(vec) => vec.get(index).cloned(),216 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),217 Self::Extended(v) => {218 let a_len = v.0.len();219 if a_len > index {220 v.0.get_lazy(index)221 } else {222 v.1.get_lazy(index - a_len)223 }224 }225 }226 }227228 pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {229 Ok(match self {230 Self::Lazy(vec) => {231 let mut out = Vec::with_capacity(vec.len());232 for item in vec.iter() {233 out.push(item.evaluate()?);234 }235 Cc::new(out)236 }237 Self::Eager(vec) => vec.clone(),238 Self::Extended(_v) => {239 let mut out = Vec::with_capacity(self.len());240 for item in self.iter() {241 out.push(item?);242 }243 Cc::new(out)244 }245 })246 }247248 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {249 (0..self.len()).map(move |idx| match self {250 Self::Lazy(l) => l[idx].evaluate(),251 Self::Eager(e) => Ok(e[idx].clone()),252 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),253 })254 }255256 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {257 (0..self.len()).map(move |idx| match self {258 Self::Lazy(l) => l[idx].clone(),259 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),260 Self::Extended(_) => self.get_lazy(idx).unwrap(),261 })262 }263264 pub fn reversed(self) -> Self {265 match self {266 Self::Lazy(vec) => {267 let mut out = (&vec as &Vec<_>).clone();268 out.reverse();269 Self::Lazy(Cc::new(out))270 }271 Self::Eager(vec) => {272 let mut out = (&vec as &Vec<_>).clone();273 out.reverse();274 Self::Eager(Cc::new(out))275 }276 Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),277 }278 }279280 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {281 let mut out = Vec::with_capacity(self.len());282283 for value in self.iter() {284 out.push(mapper(value?)?);285 }286287 Ok(Self::Eager(Cc::new(out)))288 }289290 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {291 let mut out = Vec::with_capacity(self.len());292293 for value in self.iter() {294 let value = value?;295 if filter(&value)? {296 out.push(value);297 }298 }299300 Ok(Self::Eager(Cc::new(out)))301 }302303 pub fn ptr_eq(a: &Self, b: &Self) -> bool {304 match (a, b) {305 (Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),306 (Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),307 _ => false,308 }309 }310}311312impl From<Vec<LazyVal>> for ArrValue {313 fn from(v: Vec<LazyVal>) -> Self {314 Self::Lazy(Cc::new(v))315 }316}317318impl From<Vec<Val>> for ArrValue {319 fn from(v: Vec<Val>) -> Self {320 Self::Eager(Cc::new(v))321 }322}323324pub enum IndexableVal {325 Str(IStr),326 Arr(ArrValue),327}328329#[derive(Debug, Clone, Trace)]330pub enum Val {331 Bool(bool),332 Null,333 Str(IStr),334 Num(f64),335 Arr(ArrValue),336 Obj(ObjValue),337 Func(FuncVal),338}339340impl Val {341 342 343 pub fn new_checked_num(num: f64) -> Result<Self> {344 if num.is_finite() {345 Ok(Self::Num(num))346 } else {347 throw!(RuntimeError("overflow".into()))348 }349 }350351 pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {352 Ok(match self {353 Val::Null => None,354 Val::Num(num) => Some(num),355 _ => throw!(TypeMismatch(356 context,357 vec![ValType::Null, ValType::Num],358 self.value_type()359 )),360 })361 }362 pub const fn value_type(&self) -> ValType {363 match self {364 Self::Str(..) => ValType::Str,365 Self::Num(..) => ValType::Num,366 Self::Arr(..) => ValType::Arr,367 Self::Obj(..) => ValType::Obj,368 Self::Bool(_) => ValType::Bool,369 Self::Null => ValType::Null,370 Self::Func(..) => ValType::Func,371 }372 }373374 pub fn to_string(&self) -> Result<IStr> {375 Ok(match self {376 Self::Bool(true) => "true".into(),377 Self::Bool(false) => "false".into(),378 Self::Null => "null".into(),379 Self::Str(s) => s.clone(),380 v => manifest_json_ex(381 v,382 &ManifestJsonOptions {383 padding: "",384 mtype: ManifestType::ToString,385 newline: "\n",386 key_val_sep: ": ",387 },388 )?389 .into(),390 })391 }392393 394 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {395 let obj = match self {396 Self::Obj(obj) => obj,397 _ => throw!(MultiManifestOutputIsNotAObject),398 };399 let keys = obj.fields();400 let mut out = Vec::with_capacity(keys.len());401 for key in keys {402 let value = obj403 .get(key.clone())?404 .expect("item in object")405 .manifest(ty)?;406 out.push((key, value));407 }408 Ok(out)409 }410411 412 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {413 let arr = match self {414 Self::Arr(a) => a,415 _ => throw!(StreamManifestOutputIsNotAArray),416 };417 let mut out = Vec::with_capacity(arr.len());418 for i in arr.iter() {419 out.push(i?.manifest(ty)?);420 }421 Ok(out)422 }423424 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {425 Ok(match ty {426 ManifestFormat::YamlStream(format) => {427 let arr = match self {428 Self::Arr(a) => a,429 _ => throw!(StreamManifestOutputIsNotAArray),430 };431 let mut out = String::new();432433 match format as &ManifestFormat {434 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),435 ManifestFormat::String => throw!(StreamManifestCannotNestString),436 _ => {}437 };438439 if !arr.is_empty() {440 for v in arr.iter() {441 out.push_str("---\n");442 out.push_str(&v?.manifest(format)?);443 out.push('\n');444 }445 out.push_str("...");446 }447448 out.into()449 }450 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,451 ManifestFormat::Json(padding) => self.to_json(*padding)?,452 ManifestFormat::ToString => self.to_string()?,453 ManifestFormat::String => match self {454 Self::Str(s) => s.clone(),455 _ => throw!(StringManifestOutputIsNotAString),456 },457 })458 }459460 461 pub fn to_json(&self, padding: usize) -> Result<IStr> {462 manifest_json_ex(463 self,464 &ManifestJsonOptions {465 padding: &" ".repeat(padding),466 mtype: if padding == 0 {467 ManifestType::Minify468 } else {469 ManifestType::Manifest470 },471 newline: "\n",472 key_val_sep: ": ",473 },474 )475 .map(|s| s.into())476 }477478 479 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {480 manifest_json_ex(481 self,482 &ManifestJsonOptions {483 padding: &" ".repeat(padding),484 mtype: ManifestType::Std,485 newline: "\n",486 key_val_sep: ": ",487 },488 )489 .map(|s| s.into())490 }491492 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {493 let padding = &" ".repeat(padding);494 manifest_yaml_ex(495 self,496 &ManifestYamlOptions {497 padding,498 arr_element_padding: padding,499 quote_keys: false,500 },501 )502 .map(|s| s.into())503 }504 pub fn into_indexable(self) -> Result<IndexableVal> {505 Ok(match self {506 Val::Str(s) => IndexableVal::Str(s),507 Val::Arr(arr) => IndexableVal::Arr(arr),508 _ => throw!(ValueIsNotIndexable(self.value_type())),509 })510 }511}512513const fn is_function_like(val: &Val) -> bool {514 matches!(val, Val::Func(_))515}516517518pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {519 Ok(match (val_a, val_b) {520 (Val::Bool(a), Val::Bool(b)) => a == b,521 (Val::Null, Val::Null) => true,522 (Val::Str(a), Val::Str(b)) => a == b,523 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,524 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(525 "primitiveEquals operates on primitive types, got array".into(),526 )),527 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(528 "primitiveEquals operates on primitive types, got object".into(),529 )),530 (a, b) if is_function_like(a) && is_function_like(b) => {531 throw!(RuntimeError("cannot test equality of functions".into()))532 }533 (_, _) => false,534 })535}536537538pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {539 if val_a.value_type() != val_b.value_type() {540 return Ok(false);541 }542 match (val_a, val_b) {543 (Val::Arr(a), Val::Arr(b)) => {544 if ArrValue::ptr_eq(a, b) {545 return Ok(true);546 }547 if a.len() != b.len() {548 return Ok(false);549 }550 for (a, b) in a.iter().zip(b.iter()) {551 if !equals(&a?, &b?)? {552 return Ok(false);553 }554 }555 Ok(true)556 }557 (Val::Obj(a), Val::Obj(b)) => {558 if ObjValue::ptr_eq(a, b) {559 return Ok(true);560 }561 let fields = a.fields();562 if fields != b.fields() {563 return Ok(false);564 }565 for field in fields {566 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {567 return Ok(false);568 }569 }570 Ok(true)571 }572 (a, b) => Ok(primitive_equals(a, b)?),573 }574}