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 native::NativeCallback,11 throw, Context, ObjValue, Result,12};13use gcmodule::{Cc, Trace};14use jrsonnet_interner::IStr;15use jrsonnet_parser::{ExprLocation, LocExpr, ParamsDesc};16use jrsonnet_types::ValType;17use std::{cell::RefCell, fmt::Debug, rc::Rc};1819pub trait LazyValValue: Trace {20 fn get(self: Box<Self>) -> Result<Val>;21}2223#[derive(Trace)]24enum LazyValInternals {25 Computed(Val),26 Errored(LocError),27 Waiting(TraceBox<dyn LazyValValue>),28 Pending,29}3031#[derive(Clone, Trace)]32pub struct LazyVal(Cc<RefCell<LazyValInternals>>);33impl LazyVal {34 pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {35 Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))36 }37 pub fn new_resolved(val: Val) -> Self {38 Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))39 }40 pub fn force(&self) -> Result<()> {41 self.evaluate()?;42 Ok(())43 }44 pub fn evaluate(&self) -> Result<Val> {45 match &*self.0.borrow() {46 LazyValInternals::Computed(v) => return Ok(v.clone()),47 LazyValInternals::Errored(e) => return Err(e.clone()),48 LazyValInternals::Pending => return Err(RecursiveLazyValueEvaluation.into()),49 _ => (),50 };51 let value = if let LazyValInternals::Waiting(value) =52 std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)53 {54 value55 } else {56 unreachable!()57 };58 let new_value = match value.0.get() {59 Ok(v) => v,60 Err(e) => {61 *self.0.borrow_mut() = LazyValInternals::Errored(e.clone());62 return Err(e);63 }64 };65 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());66 Ok(new_value)67 }68}6970impl Debug for LazyVal {71 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {72 write!(f, "Lazy")73 }74}75impl PartialEq for LazyVal {76 fn eq(&self, other: &Self) -> bool {77 cc_ptr_eq(&self.0, &other.0)78 }79}8081#[derive(Debug, PartialEq, Trace)]82pub struct FuncDesc {83 pub name: IStr,84 pub ctx: Context,85 pub params: ParamsDesc,86 pub body: LocExpr,87}8889#[derive(Trace)]90pub enum FuncVal {91 92 Normal(FuncDesc),93 94 StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),9596 Builtin(TraceBox<dyn Builtin>),97 98 NativeExt(IStr, Cc<NativeCallback>),99}100101impl Debug for FuncVal {102 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {103 match self {104 Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),105 Self::StaticBuiltin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),106 Self::Builtin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),107 Self::NativeExt(arg0, arg1) => {108 f.debug_tuple("NativeExt").field(arg0).field(arg1).finish()109 }110 }111 }112}113114impl PartialEq for FuncVal {115 fn eq(&self, other: &Self) -> bool {116 match (self, other) {117 (Self::Normal(a), Self::Normal(b)) => a == b,118 (Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),119 (Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,120 (..) => false,121 }122 }123}124impl FuncVal {125 pub fn args_len(&self) -> usize {126 match self {127 Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),128 Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),129 Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),130 Self::NativeExt(_, n) => n.params.iter().filter(|p| p.1.is_none()).count(),131 }132 }133 pub fn name(&self) -> IStr {134 match self {135 Self::Normal(normal) => normal.name.clone(),136 Self::StaticBuiltin(builtin) => builtin.name().into(),137 Self::Builtin(builtin) => builtin.name().into(),138 Self::NativeExt(n, _) => format!("native.{}", n).into(),139 }140 }141 pub fn evaluate(142 &self,143 call_ctx: Context,144 loc: Option<&ExprLocation>,145 args: &dyn ArgsLike,146 tailstrict: bool,147 ) -> Result<Val> {148 match self {149 Self::Normal(func) => {150 let ctx = parse_function_call(151 call_ctx,152 func.ctx.clone(),153 &func.params,154 args,155 tailstrict,156 )?;157 evaluate(ctx, &func.body)158 }159 Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),160 Self::Builtin(b) => b.call(call_ctx, loc, args),161 Self::NativeExt(_name, handler) => {162 let args =163 parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;164 let mut out_args = Vec::with_capacity(handler.params.len());165 for p in handler.params.0.iter() {166 out_args.push(args.binding(p.0.clone())?.evaluate()?);167 }168 Ok(handler.call(loc.expect("todo").0.clone(), &out_args)?)169 }170 }171 }172 pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {173 self.evaluate(Context::default(), None, args, true)174 }175}176177#[derive(Clone)]178pub enum ManifestFormat {179 YamlStream(Box<ManifestFormat>),180 Yaml(usize),181 Json(usize),182 ToString,183 String,184}185186#[derive(Debug, Clone, Trace)]187#[force_tracking]188pub enum ArrValue {189 Bytes(#[skip_trace] Rc<[u8]>),190 Lazy(Cc<Vec<LazyVal>>),191 Eager(Cc<Vec<Val>>),192 Extended(Box<(Self, Self)>),193}194impl ArrValue {195 pub fn new_eager() -> Self {196 Self::Eager(Cc::new(Vec::new()))197 }198199 pub fn len(&self) -> usize {200 match self {201 Self::Bytes(i) => i.len(),202 Self::Lazy(l) => l.len(),203 Self::Eager(e) => e.len(),204 Self::Extended(v) => v.0.len() + v.1.len(),205 }206 }207208 pub fn is_empty(&self) -> bool {209 self.len() == 0210 }211212 pub fn get(&self, index: usize) -> Result<Option<Val>> {213 match self {214 Self::Bytes(i) => i215 .get(index)216 .map_or(Ok(None), |v| Ok(Some(Val::Num(*v as f64)))),217 Self::Lazy(vec) => {218 if let Some(v) = vec.get(index) {219 Ok(Some(v.evaluate()?))220 } else {221 Ok(None)222 }223 }224 Self::Eager(vec) => Ok(vec.get(index).cloned()),225 Self::Extended(v) => {226 let a_len = v.0.len();227 if a_len > index {228 v.0.get(index)229 } else {230 v.1.get(index - a_len)231 }232 }233 }234 }235236 pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {237 match self {238 Self::Bytes(i) => i239 .get(index)240 .map(|b| LazyVal::new_resolved(Val::Num(*b as f64))),241 Self::Lazy(vec) => vec.get(index).cloned(),242 Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),243 Self::Extended(v) => {244 let a_len = v.0.len();245 if a_len > index {246 v.0.get_lazy(index)247 } else {248 v.1.get_lazy(index - a_len)249 }250 }251 }252 }253254 pub fn evaluated(&self) -> Result<Cc<Vec<Val>>> {255 Ok(match self {256 Self::Bytes(i) => {257 let mut out = Vec::with_capacity(i.len());258 for v in i.iter() {259 out.push(Val::Num(*v as f64));260 }261 Cc::new(out)262 }263 Self::Lazy(vec) => {264 let mut out = Vec::with_capacity(vec.len());265 for item in vec.iter() {266 out.push(item.evaluate()?);267 }268 Cc::new(out)269 }270 Self::Eager(vec) => vec.clone(),271 Self::Extended(_v) => {272 let mut out = Vec::with_capacity(self.len());273 for item in self.iter() {274 out.push(item?);275 }276 Cc::new(out)277 }278 })279 }280281 pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {282 (0..self.len()).map(move |idx| match self {283 Self::Bytes(b) => Ok(Val::Num(b[idx] as f64)),284 Self::Lazy(l) => l[idx].evaluate(),285 Self::Eager(e) => Ok(e[idx].clone()),286 Self::Extended(_) => self.get(idx).map(|e| e.unwrap()),287 })288 }289290 pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {291 (0..self.len()).map(move |idx| match self {292 Self::Bytes(b) => LazyVal::new_resolved(Val::Num(b[idx] as f64)),293 Self::Lazy(l) => l[idx].clone(),294 Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),295 Self::Extended(_) => self.get_lazy(idx).unwrap(),296 })297 }298299 pub fn reversed(self) -> Self {300 match self {301 Self::Bytes(b) => {302 let mut out = b.to_vec();303 out.reverse();304 Self::Bytes(out.into())305 }306 Self::Lazy(vec) => {307 let mut out = (&vec as &Vec<_>).clone();308 out.reverse();309 Self::Lazy(Cc::new(out))310 }311 Self::Eager(vec) => {312 let mut out = (&vec as &Vec<_>).clone();313 out.reverse();314 Self::Eager(Cc::new(out))315 }316 Self::Extended(b) => Self::Extended(Box::new((b.1.reversed(), b.0.reversed()))),317 }318 }319320 pub fn map(self, mapper: impl Fn(Val) -> Result<Val>) -> Result<Self> {321 let mut out = Vec::with_capacity(self.len());322323 for value in self.iter() {324 out.push(mapper(value?)?);325 }326327 Ok(Self::Eager(Cc::new(out)))328 }329330 pub fn filter(self, filter: impl Fn(&Val) -> Result<bool>) -> Result<Self> {331 let mut out = Vec::with_capacity(self.len());332333 for value in self.iter() {334 let value = value?;335 if filter(&value)? {336 out.push(value);337 }338 }339340 Ok(Self::Eager(Cc::new(out)))341 }342343 pub fn ptr_eq(a: &Self, b: &Self) -> bool {344 match (a, b) {345 (Self::Lazy(a), Self::Lazy(b)) => cc_ptr_eq(a, b),346 (Self::Eager(a), Self::Eager(b)) => cc_ptr_eq(a, b),347 _ => false,348 }349 }350}351352impl From<Vec<LazyVal>> for ArrValue {353 fn from(v: Vec<LazyVal>) -> Self {354 Self::Lazy(Cc::new(v))355 }356}357358impl From<Vec<Val>> for ArrValue {359 fn from(v: Vec<Val>) -> Self {360 Self::Eager(Cc::new(v))361 }362}363364pub enum IndexableVal {365 Str(IStr),366 Arr(ArrValue),367}368369#[derive(Debug, Clone, Trace)]370pub enum Val {371 Bool(bool),372 Null,373 Str(IStr),374 Num(f64),375 Arr(ArrValue),376 Obj(ObjValue),377 Func(Cc<FuncVal>),378}379380impl Val {381 382 383 pub fn new_checked_num(num: f64) -> Result<Self> {384 if num.is_finite() {385 Ok(Self::Num(num))386 } else {387 throw!(RuntimeError("overflow".into()))388 }389 }390391 pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {392 Ok(match self {393 Val::Null => None,394 Val::Num(num) => Some(num),395 _ => throw!(TypeMismatch(396 context,397 vec![ValType::Null, ValType::Num],398 self.value_type()399 )),400 })401 }402 pub const fn value_type(&self) -> ValType {403 match self {404 Self::Str(..) => ValType::Str,405 Self::Num(..) => ValType::Num,406 Self::Arr(..) => ValType::Arr,407 Self::Obj(..) => ValType::Obj,408 Self::Bool(_) => ValType::Bool,409 Self::Null => ValType::Null,410 Self::Func(..) => ValType::Func,411 }412 }413414 pub fn to_string(&self) -> Result<IStr> {415 Ok(match self {416 Self::Bool(true) => "true".into(),417 Self::Bool(false) => "false".into(),418 Self::Null => "null".into(),419 Self::Str(s) => s.clone(),420 v => manifest_json_ex(421 v,422 &ManifestJsonOptions {423 padding: "",424 mtype: ManifestType::ToString,425 newline: "\n",426 key_val_sep: ": ",427 },428 )?429 .into(),430 })431 }432433 434 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {435 let obj = match self {436 Self::Obj(obj) => obj,437 _ => throw!(MultiManifestOutputIsNotAObject),438 };439 let keys = obj.fields();440 let mut out = Vec::with_capacity(keys.len());441 for key in keys {442 let value = obj443 .get(key.clone())?444 .expect("item in object")445 .manifest(ty)?;446 out.push((key, value));447 }448 Ok(out)449 }450451 452 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {453 let arr = match self {454 Self::Arr(a) => a,455 _ => throw!(StreamManifestOutputIsNotAArray),456 };457 let mut out = Vec::with_capacity(arr.len());458 for i in arr.iter() {459 out.push(i?.manifest(ty)?);460 }461 Ok(out)462 }463464 pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {465 Ok(match ty {466 ManifestFormat::YamlStream(format) => {467 let arr = match self {468 Self::Arr(a) => a,469 _ => throw!(StreamManifestOutputIsNotAArray),470 };471 let mut out = String::new();472473 match format as &ManifestFormat {474 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),475 ManifestFormat::String => throw!(StreamManifestCannotNestString),476 _ => {}477 };478479 if !arr.is_empty() {480 for v in arr.iter() {481 out.push_str("---\n");482 out.push_str(&v?.manifest(format)?);483 out.push('\n');484 }485 out.push_str("...");486 }487488 out.into()489 }490 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,491 ManifestFormat::Json(padding) => self.to_json(*padding)?,492 ManifestFormat::ToString => self.to_string()?,493 ManifestFormat::String => match self {494 Self::Str(s) => s.clone(),495 _ => throw!(StringManifestOutputIsNotAString),496 },497 })498 }499500 501 pub fn to_json(&self, padding: usize) -> Result<IStr> {502 manifest_json_ex(503 self,504 &ManifestJsonOptions {505 padding: &" ".repeat(padding),506 mtype: if padding == 0 {507 ManifestType::Minify508 } else {509 ManifestType::Manifest510 },511 newline: "\n",512 key_val_sep: ": ",513 },514 )515 .map(|s| s.into())516 }517518 519 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {520 manifest_json_ex(521 self,522 &ManifestJsonOptions {523 padding: &" ".repeat(padding),524 mtype: ManifestType::Std,525 newline: "\n",526 key_val_sep: ": ",527 },528 )529 .map(|s| s.into())530 }531532 pub fn to_yaml(&self, padding: usize) -> Result<IStr> {533 let padding = &" ".repeat(padding);534 manifest_yaml_ex(535 self,536 &ManifestYamlOptions {537 padding,538 arr_element_padding: padding,539 quote_keys: false,540 },541 )542 .map(|s| s.into())543 }544 pub fn into_indexable(self) -> Result<IndexableVal> {545 Ok(match self {546 Val::Str(s) => IndexableVal::Str(s),547 Val::Arr(arr) => IndexableVal::Arr(arr),548 _ => throw!(ValueIsNotIndexable(self.value_type())),549 })550 }551}552553const fn is_function_like(val: &Val) -> bool {554 matches!(val, Val::Func(_))555}556557558pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {559 Ok(match (val_a, val_b) {560 (Val::Bool(a), Val::Bool(b)) => a == b,561 (Val::Null, Val::Null) => true,562 (Val::Str(a), Val::Str(b)) => a == b,563 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,564 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(565 "primitiveEquals operates on primitive types, got array".into(),566 )),567 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(568 "primitiveEquals operates on primitive types, got object".into(),569 )),570 (a, b) if is_function_like(a) && is_function_like(b) => {571 throw!(RuntimeError("cannot test equality of functions".into()))572 }573 (_, _) => false,574 })575}576577578pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {579 if val_a.value_type() != val_b.value_type() {580 return Ok(false);581 }582 match (val_a, val_b) {583 (Val::Arr(a), Val::Arr(b)) => {584 if ArrValue::ptr_eq(a, b) {585 return Ok(true);586 }587 if a.len() != b.len() {588 return Ok(false);589 }590 for (a, b) in a.iter().zip(b.iter()) {591 if !equals(&a?, &b?)? {592 return Ok(false);593 }594 }595 Ok(true)596 }597 (Val::Obj(a), Val::Obj(b)) => {598 if ObjValue::ptr_eq(a, b) {599 return Ok(true);600 }601 let fields = a.fields();602 if fields != b.fields() {603 return Ok(false);604 }605 for field in fields {606 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {607 return Ok(false);608 }609 }610 Ok(true)611 }612 (a, b) => Ok(primitive_equals(a, b)?),613 }614}