difftreelog
refactor! remove Lazy from Val
in: master
Now lazy is used only in objects/arrays BREAKING CHANGE: value_type() is never fails
9 files changed
bindings/jsonnet/src/val_extract.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/val_extract.rs
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -9,7 +9,7 @@
#[no_mangle]
pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {
- match v.unwrap_if_lazy().unwrap() {
+ match v {
Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
_ => std::ptr::null_mut(),
}
@@ -20,9 +20,9 @@
v: &Val,
out: &mut c_double,
) -> c_int {
- match v.unwrap_if_lazy().unwrap() {
+ match v {
Val::Num(n) => {
- *out = n;
+ *out = *n;
1
}
_ => 0,
@@ -30,7 +30,7 @@
}
#[no_mangle]
pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {
- match v.unwrap_if_lazy().unwrap() {
+ match v {
Val::Bool(false) => 0,
Val::Bool(true) => 1,
_ => 2,
@@ -38,7 +38,7 @@
}
#[no_mangle]
pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {
- match v.unwrap_if_lazy().unwrap() {
+ match v {
Val::Null => 1,
_ => 0,
}
crates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};5use jrsonnet_types::ValType;6use thiserror::Error;78#[derive(Debug, Clone, Error)]9pub enum FormatError {10 #[error("truncated format code")]11 TruncatedFormatCode,12 #[error("unrecognized conversion type: {0}")]13 UnrecognizedConversionType(char),1415 #[error("not enough values")]16 NotEnoughValues,1718 #[error("cannot use * width with object")]19 CannotUseStarWidthWithObject,20 #[error("mapping keys required")]21 MappingKeysRequired,22 #[error("no such format field: {0}")]23 NoSuchFormatField(Rc<str>),24}2526impl From<FormatError> for LocError {27 fn from(e: FormatError) -> Self {28 Self::new(Format(e))29 }30}3132use std::rc::Rc;33use FormatError::*;3435type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;3637pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {38 if str.is_empty() {39 return Err(TruncatedFormatCode);40 }41 let bytes = str.as_bytes();42 if bytes[0] == b'(' {43 let mut i = 1;44 while i < bytes.len() {45 if bytes[i] == b')' {46 return Ok((&str[1..i as usize], &str[i as usize + 1..]));47 }48 i += 1;49 }50 Err(TruncatedFormatCode)51 } else {52 Ok(("", str))53 }54}5556#[cfg(test)]57pub mod tests_key {58 use super::*;5960 #[test]61 fn parse_key() {62 assert_eq!(63 try_parse_mapping_key("(hello ) world").unwrap(),64 ("hello ", " world")65 );66 assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));67 assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));68 assert_eq!(69 try_parse_mapping_key(" () world").unwrap(),70 ("", " () world")71 );72 }7374 #[test]75 #[should_panic]76 fn parse_key_missing_start() {77 try_parse_mapping_key("").unwrap();78 }7980 #[test]81 #[should_panic]82 fn parse_key_missing_end() {83 try_parse_mapping_key("( ").unwrap();84 }85}8687#[derive(Default, Debug)]88pub struct CFlags {89 pub alt: bool,90 pub zero: bool,91 pub left: bool,92 pub blank: bool,93 pub sign: bool,94}9596pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {97 if str.is_empty() {98 return Err(TruncatedFormatCode);99 }100 let bytes = str.as_bytes();101 let mut i = 0;102 let mut out = CFlags::default();103 loop {104 if bytes.len() == i {105 return Err(TruncatedFormatCode);106 }107 match bytes[i] {108 b'#' => out.alt = true,109 b'0' => out.zero = true,110 b'-' => out.left = true,111 b' ' => out.blank = true,112 b'+' => out.sign = true,113 _ => break,114 }115 i += 1;116 }117 Ok((out, &str[i..]))118}119120#[derive(Debug, PartialEq)]121pub enum Width {122 Star,123 Fixed(usize),124}125pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {126 if str.is_empty() {127 return Err(TruncatedFormatCode);128 }129 let bytes = str.as_bytes();130 if bytes[0] == b'*' {131 return Ok((Width::Star, &str[1..]));132 }133 let mut out: usize = 0;134 let mut digits = 0;135 while let Some(digit) = (bytes[digits] as char).to_digit(10) {136 out *= 10;137 out += digit as usize;138 digits += 1;139 if digits == bytes.len() {140 return Err(TruncatedFormatCode);141 }142 }143 Ok((Width::Fixed(out), &str[digits..]))144}145146pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {147 if str.is_empty() {148 return Err(TruncatedFormatCode);149 }150 let bytes = str.as_bytes();151 if bytes[0] == b'.' {152 try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))153 } else {154 Ok((None, str))155 }156}157158// Only skips159pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {160 if str.is_empty() {161 return Err(TruncatedFormatCode);162 }163 let bytes = str.as_bytes();164 let mut idx = 0;165 while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {166 idx += 1;167 if bytes.len() == idx {168 return Err(TruncatedFormatCode);169 }170 }171 Ok(((), &str[idx..]))172}173174#[derive(Debug, PartialEq)]175pub enum ConvTypeV {176 Decimal,177 Octal,178 Hexadecimal,179 Scientific,180 Float,181 Shorter,182 Char,183 String,184 Percent,185}186pub struct ConvType {187 v: ConvTypeV,188 caps: bool,189}190191pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {192 if str.is_empty() {193 return Err(TruncatedFormatCode);194 }195196 let code = str.as_bytes()[0];197 let v: (ConvTypeV, bool) = match code {198 b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),199 b'o' => (ConvTypeV::Octal, false),200 b'x' => (ConvTypeV::Hexadecimal, false),201 b'X' => (ConvTypeV::Hexadecimal, true),202 b'e' => (ConvTypeV::Scientific, false),203 b'E' => (ConvTypeV::Scientific, true),204 b'f' => (ConvTypeV::Float, false),205 b'F' => (ConvTypeV::Float, true),206 b'g' => (ConvTypeV::Shorter, false),207 b'G' => (ConvTypeV::Shorter, true),208 b'c' => (ConvTypeV::Char, false),209 b's' => (ConvTypeV::String, false),210 b'%' => (ConvTypeV::Percent, false),211 c => return Err(UnrecognizedConversionType(c as char)),212 };213214 Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))215}216217#[derive(Debug)]218pub struct Code<'s> {219 mkey: &'s str,220 cflags: CFlags,221 width: Width,222 precision: Option<Width>,223 convtype: ConvTypeV,224 caps: bool,225}226pub fn parse_code(str: &str) -> ParseResult<Code> {227 if str.is_empty() {228 return Err(TruncatedFormatCode);229 }230 let (mkey, str) = try_parse_mapping_key(str)?;231 let (cflags, str) = try_parse_cflags(str)?;232 let (width, str) = try_parse_field_width(str)?;233 let (precision, str) = try_parse_precision(str)?;234 let (_, str) = try_parse_length_modifier(str)?;235 let (convtype, str) = parse_conversion_type(str)?;236237 Ok((238 Code {239 mkey,240 cflags,241 width,242 precision,243 convtype: convtype.v,244 caps: convtype.caps,245 },246 str,247 ))248}249250#[derive(Debug)]251pub enum Element<'s> {252 String(&'s str),253 Code(Code<'s>),254}255pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {256 let mut bytes = str.as_bytes();257 let mut out = vec![];258 let mut offset = 0;259260 loop {261 while offset != bytes.len() && bytes[offset] != b'%' {262 offset += 1;263 }264 if offset != 0 {265 out.push(Element::String(&str[0..offset]));266 }267 if offset == bytes.len() {268 return Ok(out);269 }270 str = &str[offset + 1..];271 let (code, nstr) = parse_code(str)?;272 str = nstr;273 bytes = str.as_bytes();274 offset = 0;275276 out.push(Element::Code(code))277 }278}279280const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";281282#[inline]283pub fn render_integer(284 out: &mut String,285 iv: i64,286 padding: usize,287 precision: usize,288 blank: bool,289 sign: bool,290 radix: i64,291 prefix: &str,292 caps: bool,293) {294 // Digit char indexes in reverse order, i.e295 // for radix = 16 and n = 12f: [15, 2, 1]296 let digits = if iv == 0 {297 vec![0u8]298 } else {299 let mut v = iv.abs();300 let mut nums = Vec::with_capacity(1);301 while v > 0 {302 nums.push((v % radix) as u8);303 v /= radix;304 }305 nums306 };307 let neg = iv < 0;308 let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });309 let zp2 = zp310 .max(precision)311 .saturating_sub(prefix.len() + digits.len());312313 if neg {314 out.push('-')315 } else if sign {316 out.push('+');317 } else if blank {318 out.push(' ');319 }320321 out.reserve(zp2);322 for _ in 0..zp2 {323 out.push('0');324 }325 out.push_str(prefix);326327 for digit in digits.into_iter().rev() {328 let ch = NUMBERS[digit as usize] as char;329 out.push(if caps { ch.to_ascii_uppercase() } else { ch });330 }331}332333pub fn render_decimal(334 out: &mut String,335 iv: i64,336 padding: usize,337 precision: usize,338 blank: bool,339 sign: bool,340) {341 render_integer(out, iv, padding, precision, blank, sign, 10, "", false)342}343pub fn render_octal(344 out: &mut String,345 iv: i64,346 padding: usize,347 precision: usize,348 alt: bool,349 blank: bool,350 sign: bool,351) {352 render_integer(353 out,354 iv,355 padding,356 precision,357 blank,358 sign,359 8,360 if alt && iv != 0 { "0" } else { "" },361 false,362 )363}364pub fn render_hexadecimal(365 out: &mut String,366 iv: i64,367 padding: usize,368 precision: usize,369 alt: bool,370 blank: bool,371 sign: bool,372 caps: bool,373) {374 render_integer(375 out,376 iv,377 padding,378 precision,379 blank,380 sign,381 16,382 match (alt, caps) {383 (true, true) => "0X",384 (true, false) => "0x",385 (false, _) => "",386 },387 caps,388 )389}390391pub fn render_float(392 out: &mut String,393 n: f64,394 mut padding: usize,395 precision: usize,396 blank: bool,397 sign: bool,398 ensure_pt: bool,399 trailing: bool,400) {401 let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };402 padding = padding.saturating_sub(dot_size + precision);403 render_decimal(out, n.floor() as i64, padding, 0, blank, sign);404 if precision == 0 {405 if ensure_pt {406 out.push('.');407 }408 return;409 }410 let frac = n411 .fract()412 .mul_add(10.0_f64.powf(precision as f64), 0.5)413 .floor();414 if trailing || frac > 0.0 {415 out.push('.');416 let mut frac_str = String::new();417 render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);418 let mut trim = frac_str.len();419 if !trailing {420 for b in frac_str.as_bytes().iter().rev() {421 if *b == b'0' {422 trim -= 1;423 }424 }425 }426 out.push_str(&frac_str[..trim]);427 } else if ensure_pt {428 out.push('.');429 }430}431432pub fn render_float_sci(433 out: &mut String,434 n: f64,435 mut padding: usize,436 precision: usize,437 blank: bool,438 sign: bool,439 ensure_pt: bool,440 trailing: bool,441 caps: bool,442) {443 let exponent = n.log10().floor();444 let mantissa = if exponent as i16 == -324 {445 n * 10.0 / 10.0_f64.powf(exponent + 1.0)446 } else {447 n / 10.0_f64.powf(exponent)448 };449 let mut exponent_str = String::new();450 render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);451452 // +1 for e453 padding = padding.saturating_sub(exponent_str.len() + 1);454455 render_float(456 out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,457 );458 out.push(if caps { 'E' } else { 'e' });459 out.push_str(&exponent_str);460}461462pub fn format_code(463 out: &mut String,464 value: &Val,465 code: &Code,466 width: usize,467 precision: Option<usize>,468) -> Result<()> {469 let clfags = &code.cflags;470 let (fpprec, iprec) = match precision {471 Some(v) => (v, v),472 None => (6, 0),473 };474 let padding = if clfags.zero && !clfags.left {475 width476 } else {477 0478 };479480 // TODO: If left padded, can optimize by writing directly to out481 let mut tmp_out = String::new();482483 match code.convtype {484 ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),485 ConvTypeV::Decimal => {486 let value = value.clone().try_cast_num("%d/%u/%i requires number")?;487 render_decimal(488 &mut tmp_out,489 value as i64,490 padding,491 iprec,492 clfags.blank,493 clfags.sign,494 );495 }496 ConvTypeV::Octal => {497 let value = value.clone().try_cast_num("%o requires number")?;498 render_octal(499 &mut tmp_out,500 value as i64,501 padding,502 iprec,503 clfags.alt,504 clfags.blank,505 clfags.sign,506 );507 }508 ConvTypeV::Hexadecimal => {509 let value = value.clone().try_cast_num("%x/%X requires number")?;510 render_hexadecimal(511 &mut tmp_out,512 value as i64,513 padding,514 iprec,515 clfags.alt,516 clfags.blank,517 clfags.sign,518 code.caps,519 );520 }521 ConvTypeV::Scientific => {522 let value = value.clone().try_cast_num("%e/%E requires number")?;523 render_float_sci(524 &mut tmp_out,525 value,526 padding,527 fpprec,528 clfags.blank,529 clfags.sign,530 clfags.alt,531 true,532 code.caps,533 );534 }535 ConvTypeV::Float => {536 let value = value.clone().try_cast_num("%e/%E requires number")?;537 render_float(538 &mut tmp_out,539 value,540 padding,541 fpprec,542 clfags.blank,543 clfags.sign,544 clfags.alt,545 true,546 );547 }548 ConvTypeV::Shorter => {549 let value = value.clone().try_cast_num("%g/%G requires number")?;550 let exponent = value.log10().floor();551 if exponent < -4.0 || exponent >= fpprec as f64 {552 render_float_sci(553 &mut tmp_out,554 value,555 padding,556 fpprec - 1,557 clfags.blank,558 clfags.sign,559 clfags.alt,560 clfags.alt,561 code.caps,562 );563 } else {564 let digits_before_pt = 1.max(exponent as usize + 1);565 render_float(566 &mut tmp_out,567 value,568 padding,569 fpprec - digits_before_pt,570 clfags.blank,571 clfags.sign,572 clfags.alt,573 clfags.alt,574 );575 }576 }577 ConvTypeV::Char => match value.clone() {578 Val::Num(n) => tmp_out.push(579 std::char::from_u32(n as u32)580 .ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,581 ),582 Val::Str(s) => {583 if s.chars().count() != 1 {584 throw!(RuntimeError(585 format!("%c expected 1 char string, got {}", s.chars().count()).into(),586 ));587 }588 tmp_out.push_str(&s);589 }590 _ => {591 throw!(TypeMismatch(592 "%c requires number/string",593 vec![ValType::Num, ValType::Str],594 value.value_type(),595 ));596 }597 },598 ConvTypeV::Percent => tmp_out.push('%'),599 };600601 let padding = width.saturating_sub(tmp_out.len());602603 if !clfags.left {604 for _ in 0..padding {605 out.push(' ');606 }607 }608 out.push_str(&tmp_out);609 if clfags.left {610 for _ in 0..padding {611 out.push(' ');612 }613 }614615 Ok(())616}617618pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {619 let codes = parse_codes(str)?;620 let mut out = String::new();621622 for code in codes {623 match code {624 Element::String(s) => {625 out.push_str(s);626 }627 Element::Code(c) => {628 let width = match c.width {629 Width::Star => {630 if values.is_empty() {631 throw!(NotEnoughValues);632 }633 let value = &values[0];634 values = &values[1..];635 value.clone().try_cast_num("field width")? as usize636 }637 Width::Fixed(n) => n,638 };639 let precision = match c.precision {640 Some(Width::Star) => {641 if values.is_empty() {642 throw!(NotEnoughValues);643 }644 let value = &values[0];645 values = &values[1..];646 Some(value.clone().try_cast_num("field precision")? as usize)647 }648 Some(Width::Fixed(n)) => Some(n),649 None => None,650 };651652 // %% should not consume a value653 let value = if c.convtype == ConvTypeV::Percent {654 &Val::Null655 } else {656 if values.is_empty() {657 throw!(NotEnoughValues);658 }659 let value = &values[0];660 values = &values[1..];661 value662 };663664 format_code(&mut out, value, &c, width, precision)?;665 }666 }667 }668669 Ok(out)670}671672pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {673 let codes = parse_codes(str)?;674 let mut out = String::new();675676 for code in codes {677 match code {678 Element::String(s) => {679 out.push_str(s);680 }681 Element::Code(c) => {682 // TODO: Operate on ref683 let f: Rc<str> = c.mkey.into();684 let width = match c.width {685 Width::Star => {686 throw!(CannotUseStarWidthWithObject);687 }688 Width::Fixed(n) => n,689 };690 let precision = match c.precision {691 Some(Width::Star) => {692 throw!(CannotUseStarWidthWithObject);693 }694 Some(Width::Fixed(n)) => Some(n),695 None => None,696 };697698 let value = if c.convtype == ConvTypeV::Percent {699 Val::Null700 } else {701 if f.is_empty() {702 throw!(MappingKeysRequired);703 }704 if let Some(v) = values.get(f.clone())? {705 v706 } else {707 throw!(NoSuchFormatField(f));708 }709 };710711 format_code(&mut out, &value, &c, width, precision)?;712 }713 }714 }715716 Ok(out)717}718719#[cfg(test)]720pub mod test_format {721 use super::*;722723 #[test]724 fn parse() {725 assert_eq!(726 parse_codes(727 "How much error budget is left looking at our %.3f%% availability gurantees?"728 )729 .unwrap()730 .len(),731 4732 );733 }734735 #[test]736 fn octals() {737 assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");738 assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");739 assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), " 10");740 assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");741 assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");742 assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");743 assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10 ");744 assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");745 assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");746 }747748 #[test]749 fn percent_doesnt_consumes_values() {750 assert_eq!(751 format_arr(752 "How much error budget is left looking at our %.3f%% availability gurantees?",753 &[Val::Num(4.0)]754 )755 .unwrap(),756 "How much error budget is left looking at our 4.000% availability gurantees?"757 );758 }759}crates/jrsonnet-evaluator/src/builtin/manifest.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -33,9 +33,9 @@
) -> Result<()> {
use std::fmt::Write;
let mtype = options.mtype;
- match val.unwrap_if_lazy()? {
+ match val {
Val::Bool(v) => {
- if v {
+ if *v {
buf.push_str("true");
} else {
buf.push_str("false");
@@ -63,7 +63,7 @@
}
}
buf.push_str(cur_padding);
- manifest_json_ex_buf(item, buf, cur_padding, options)?;
+ manifest_json_ex_buf(&item?, buf, cur_padding, options)?;
}
cur_padding.truncate(old_len);
@@ -118,7 +118,6 @@
buf.push('}');
}
Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
- Val::Lazy(_) => unreachable!(),
};
Ok(())
}
crates/jrsonnet-evaluator/src/builtin/sort.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/builtin/sort.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/sort.rs
@@ -46,7 +46,6 @@
let mut sort_type = SortKeyType::Unknown;
for i in values.iter_mut() {
let i = key_getter(i);
- i.inplace_unwrap()?;
match (i, sort_type) {
(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,
crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -1,7 +1,6 @@
use crate::{
context_creator, error::Error::*, future_wrapper, lazy_val, push, throw, with_state, Context,
ContextCreator, FuncDesc, FuncVal, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,
- ValType,
};
use closure::closure;
use jrsonnet_parser::{
@@ -9,6 +8,7 @@
ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
Visibility,
};
+use jrsonnet_types::ValType;
use rustc_hash::FxHashMap;
use std::{collections::HashMap, rc::Rc};
@@ -61,8 +61,7 @@
Ok(match field_name {
jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
jrsonnet_parser::FieldName::Dyn(expr) => {
- let lazy = evaluate(context, expr)?;
- let value = lazy.unwrap_if_lazy()?;
+ let value = evaluate(context, expr)?;
if matches!(value, Val::Null) {
None
} else {
@@ -74,11 +73,10 @@
pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {
Ok(match (op, b) {
- (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,
(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),
(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),
(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),
- (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),
+ (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
})
}
@@ -94,12 +92,17 @@
(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),
(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
- (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
+ (Val::Arr(a), Val::Arr(b)) => {
+ let mut out = Vec::with_capacity(a.len() + b.len());
+ out.extend(a.iter_lazy());
+ out.extend(b.iter_lazy());
+ Val::Arr(out.into())
+ }
(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,
_ => throw!(BinaryOperatorDoesNotOperateOnValues(
BinaryOpType::Add,
- a.value_type()?,
- b.value_type()?,
+ a.value_type(),
+ b.value_type(),
)),
})
}
@@ -110,15 +113,11 @@
op: BinaryOpType,
b: &LocExpr,
) -> Result<Val> {
- Ok(
- match (evaluate(context.clone(), a)?.unwrap_if_lazy()?, op, b) {
- (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
- (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
- (a, op, eb) => {
- evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?
- }
- },
- )
+ Ok(match (evaluate(context.clone(), a)?, op, b) {
+ (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
+ (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
+ (a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,
+ })
}
pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {
@@ -177,8 +176,8 @@
_ => throw!(BinaryOperatorDoesNotOperateOnValues(
op,
- a.value_type()?,
- b.value_type()?,
+ a.value_type(),
+ b.value_type(),
)),
})
}
@@ -200,23 +199,20 @@
None
}
}
- Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {
- match evaluate(context.clone(), expr)?.unwrap_if_lazy()? {
- Val::Arr(list) => {
- let mut out = Vec::new();
- for item in list.iter() {
- let item = item.unwrap_if_lazy()?;
- out.push(evaluate_comp(
- context.clone().with_var(var.clone(), item.clone()),
- value,
- &specs[1..],
- )?);
- }
- Some(out.into_iter().flatten().flatten().collect())
+ Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {
+ Val::Arr(list) => {
+ let mut out = Vec::new();
+ for item in list.iter() {
+ out.push(evaluate_comp(
+ context.clone().with_var(var.clone(), item?.clone()),
+ value,
+ &specs[1..],
+ )?);
}
- _ => throw!(InComprehensionCanOnlyIterateOverArray),
+ Some(out.into_iter().flatten().flatten().collect())
}
- }
+ _ => throw!(InComprehensionCanOnlyIterateOverArray),
+ },
})
}
@@ -375,7 +371,7 @@
},
);
}
- v => throw!(FieldMustBeStringGot(v.value_type()?)),
+ v => throw!(FieldMustBeStringGot(v.value_type())),
}
}
@@ -391,8 +387,7 @@
loc: &Option<ExprLocation>,
tailstrict: bool,
) -> Result<Val> {
- let lazy = evaluate(context.clone(), value)?;
- let value = lazy.unwrap_if_lazy()?;
+ let value = evaluate(context.clone(), value)?;
Ok(match value {
Val::Func(f) => {
let body = || f.evaluate(context, loc, args, tailstrict);
@@ -402,7 +397,7 @@
push(loc, || format!("function <{}> call", f.name()), body)?
}
}
- v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),
+ v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),
})
}
@@ -436,7 +431,7 @@
Var(name) => push(
loc,
|| format!("variable <{}>", name),
- || Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),
+ || Ok(context.binding(name.clone())?.evaluate()?),
)?,
Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {
let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;
@@ -444,14 +439,11 @@
.super_obj()
.clone()
.expect("no super found")
- .get_raw(name, &context.this().clone().expect("no this found"))?
+ .get_raw(name, Some(&context.this().clone().expect("no this found")))?
.expect("value not found")
}
Index(value, index) => {
- match (
- evaluate(context.clone(), value)?.unwrap_if_lazy()?,
- evaluate(context, index)?,
- ) {
+ match (evaluate(context.clone(), value)?, evaluate(context, index)?) {
(Val::Obj(v), Val::Str(s)) => {
let sn = s.clone();
push(
@@ -459,7 +451,7 @@
|| format!("field <{}> access", sn),
|| {
if let Some(v) = v.get(s.clone())? {
- Ok(v.unwrap_if_lazy()?)
+ Ok(v)
} else if v.get("__intrinsic_namespace__".into())?.is_some() {
Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))
} else {
@@ -471,23 +463,22 @@
(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Obj,
ValType::Str,
- n.value_type()?,
+ n.value_type(),
)),
(Val::Arr(v), Val::Num(n)) => {
if n.fract() > f64::EPSILON {
throw!(FractionalIndex)
}
- v.get(n as usize)
+ v.get(n as usize)?
.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
.clone()
- .unwrap_if_lazy()?
}
(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),
(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Arr,
ValType::Num,
- n.value_type()?,
+ n.value_type(),
)),
(Val::Str(s), Val::Num(n)) => Val::Str(
@@ -500,10 +491,10 @@
(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Str,
ValType::Num,
- n.value_type()?,
+ n.value_type(),
)),
- (v, _) => throw!(CantIndexInto(v.value_type()?)),
+ (v, _) => throw!(CantIndexInto(v.value_type())),
}
}
LocalExpr(bindings, returned) => {
@@ -529,17 +520,19 @@
Arr(items) => {
let mut out = Vec::with_capacity(items.len());
for item in items {
- out.push(Val::Lazy(lazy_val!(
+ out.push(LazyVal::new(Box::new(
closure!(clone context, clone item, || {
evaluate(context.clone(), &item)
- })
+ }),
)));
}
- Val::Arr(Rc::new(out))
+ Val::Arr(out.into())
}
ArrComp(expr, comp_specs) => Val::Arr(
// First comp_spec should be for_spec, so no "None" possible here
- Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?.unwrap()),
+ evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?
+ .unwrap()
+ .into(),
),
Obj(body) => Val::Obj(evaluate_object(context, body)?),
ObjExtend(s, t) => evaluate_add_op(
crates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -22,11 +22,10 @@
} else {
Number::from_f64(*n).expect("to json number")
}),
- Val::Lazy(v) => (&v.evaluate()?).try_into()?,
Val::Arr(a) => {
let mut out = Vec::with_capacity(a.len());
for item in a.iter() {
- out.push(item.try_into()?);
+ out.push((&item?).try_into()?);
}
Self::Array(out)
}
@@ -55,9 +54,9 @@
Value::Array(a) => {
let mut out = Vec::with_capacity(a.len());
for v in a {
- out.push(v.into());
+ out.push(LazyVal::new_resolved(v.into()));
}
- Self::Arr(Rc::new(out))
+ Self::Arr(out.into())
}
Value::Object(o) => {
let mut entries = HashMap::with_capacity(o.len());
crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -102,9 +102,10 @@
visible_fields
}
pub fn get(&self, key: Rc<str>) -> Result<Option<Val>> {
- Ok(self.get_raw(key, self)?)
+ Ok(self.get_raw(key, None)?)
}
- pub(crate) fn get_raw(&self, key: Rc<str>, real_this: &Self) -> Result<Option<Val>> {
+ pub(crate) fn get_raw(&self, key: Rc<str>, real_this: Option<&Self>) -> Result<Option<Val>> {
+ let real_this = real_this.unwrap_or(self);
let cache_key = (key.clone(), Rc::as_ptr(&real_this.0) as usize);
if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
@@ -115,7 +116,7 @@
(Some(k), Some(s)) => {
let our = self.evaluate_this(k, real_this)?;
if k.add {
- s.get_raw(key, real_this)?
+ s.get_raw(key, Some(real_this))?
.map_or(Ok(Some(our.clone())), |v| {
Ok(Some(evaluate_add_op(&v, &our)?))
})
@@ -123,7 +124,7 @@
Ok(Some(our))
}
}
- (None, Some(s)) => s.get_raw(key, real_this),
+ (None, Some(s)) => s.get_raw(key, Some(real_this)),
(None, None) => Ok(None),
}?;
self.0
crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -10,12 +10,8 @@
throw, with_state, Context, ObjValue, Result,
};
use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};
-use std::{
- cell::RefCell,
- collections::HashMap,
- fmt::{Debug, Display},
- rc::Rc,
-};
+use jrsonnet_types::ValType;
+use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
enum LazyValInternals {
Computed(Val),
@@ -166,43 +162,108 @@
}
}
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ValType {
- Bool,
- Null,
- Str,
- Num,
- Arr,
- Obj,
- Func,
+#[derive(Clone)]
+pub enum ManifestFormat {
+ YamlStream(Box<ManifestFormat>),
+ Yaml(usize),
+ Json(usize),
+ ToString,
+ String,
+}
+
+#[derive(Debug, Clone)]
+pub enum ArrValue {
+ Lazy(Rc<Vec<LazyVal>>),
+ Eager(Rc<Vec<Val>>),
}
-impl ValType {
- pub const fn name(&self) -> &'static str {
- use ValType::*;
+impl ArrValue {
+ pub fn len(&self) -> usize {
match self {
- Bool => "boolean",
- Null => "null",
- Str => "string",
- Num => "number",
- Arr => "array",
- Obj => "object",
- Func => "function",
+ ArrValue::Lazy(l) => l.len(),
+ ArrValue::Eager(e) => e.len(),
}
}
+
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ pub fn get(&self, index: usize) -> Result<Option<Val>> {
+ match self {
+ ArrValue::Lazy(vec) => {
+ if let Some(v) = vec.get(index) {
+ Ok(Some(v.evaluate()?))
+ } else {
+ Ok(None)
+ }
+ }
+ ArrValue::Eager(vec) => Ok(vec.get(index).cloned()),
+ }
+ }
+
+ pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {
+ match self {
+ ArrValue::Lazy(vec) => vec.get(index).cloned(),
+ ArrValue::Eager(vec) => vec
+ .get(index)
+ .cloned()
+ .map(|val| LazyVal::new_resolved(val)),
+ }
+ }
+
+ pub fn evaluated(&self) -> Result<Rc<Vec<Val>>> {
+ Ok(match self {
+ ArrValue::Lazy(vec) => {
+ let mut out = Vec::with_capacity(vec.len());
+ for item in vec.iter() {
+ out.push(item.evaluate()?);
+ }
+ Rc::new(out)
+ }
+ ArrValue::Eager(vec) => vec.clone(),
+ })
+ }
+
+ pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {
+ (0..self.len()).map(move |idx| match self {
+ ArrValue::Lazy(l) => l[idx].evaluate(),
+ ArrValue::Eager(e) => Ok(e[idx].clone()),
+ })
+ }
+
+ pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {
+ (0..self.len()).map(move |idx| match self {
+ ArrValue::Lazy(l) => l[idx].clone(),
+ ArrValue::Eager(e) => LazyVal::new_resolved(e[idx].clone()),
+ })
+ }
+
+ pub fn reversed(self) -> Self {
+ match self {
+ ArrValue::Lazy(vec) => {
+ let mut out = (&vec as &Vec<_>).clone();
+ out.reverse();
+ Self::Lazy(Rc::new(out))
+ }
+ ArrValue::Eager(vec) => {
+ let mut out = (&vec as &Vec<_>).clone();
+ out.reverse();
+ Self::Eager(Rc::new(out))
+ }
+ }
+ }
}
-impl Display for ValType {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- write!(f, "{}", self.name())
+
+impl From<Vec<LazyVal>> for ArrValue {
+ fn from(v: Vec<LazyVal>) -> Self {
+ Self::Lazy(Rc::new(v))
}
}
-#[derive(Clone)]
-pub enum ManifestFormat {
- YamlStream(Box<ManifestFormat>),
- Yaml(usize),
- Json(usize),
- ToString,
- String,
+impl From<Vec<Val>> for ArrValue {
+ fn from(v: Vec<Val>) -> Self {
+ Self::Eager(Rc::new(v))
+ }
}
#[derive(Debug, Clone)]
@@ -211,8 +272,7 @@
Null,
Str(Rc<str>),
Num(f64),
- Lazy(LazyVal),
- Arr(Rc<Vec<Val>>),
+ Arr(ArrValue),
Obj(ObjValue),
Func(Rc<FuncVal>),
}
@@ -237,40 +297,33 @@
}
pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {
- let this_type = self.value_type()?;
+ let this_type = self.value_type();
if this_type != val_type {
throw!(TypeMismatch(context, vec![val_type], this_type))
} else {
Ok(())
}
}
+ pub fn unwrap_num(self) -> Result<f64> {
+ Ok(matches_unwrap!(self, Self::Num(v), v))
+ }
+ pub fn unwrap_func(self) -> Result<Rc<FuncVal>> {
+ Ok(matches_unwrap!(self, Self::Func(v), v))
+ }
pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {
self.assert_type(context, ValType::Bool)?;
- Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))
+ Ok(matches_unwrap!(self, Self::Bool(v), v))
}
pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {
self.assert_type(context, ValType::Str)?;
- Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))
+ Ok(matches_unwrap!(self, Self::Str(v), v))
}
pub fn try_cast_num(self, context: &'static str) -> Result<f64> {
self.assert_type(context, ValType::Num)?;
- Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))
- }
- pub fn inplace_unwrap(&mut self) -> Result<()> {
- while let Self::Lazy(lazy) = self {
- *self = lazy.evaluate()?;
- }
- Ok(())
+ self.unwrap_num()
}
- pub fn unwrap_if_lazy(&self) -> Result<Self> {
- Ok(if let Self::Lazy(v) = self {
- v.evaluate()?.unwrap_if_lazy()?
- } else {
- self.clone()
- })
- }
- pub fn value_type(&self) -> Result<ValType> {
- Ok(match self {
+ pub fn value_type(&self) -> ValType {
+ match self {
Self::Str(..) => ValType::Str,
Self::Num(..) => ValType::Num,
Self::Arr(..) => ValType::Arr,
@@ -278,16 +331,15 @@
Self::Bool(_) => ValType::Bool,
Self::Null => ValType::Null,
Self::Func(..) => ValType::Func,
- Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
- })
+ }
}
pub fn to_string(&self) -> Result<Rc<str>> {
- Ok(match self.unwrap_if_lazy()? {
+ Ok(match self {
Self::Bool(true) => "true".into(),
Self::Bool(false) => "false".into(),
Self::Null => "null".into(),
- Self::Str(s) => s,
+ Self::Str(s) => s.clone(),
v => manifest_json_ex(
&v,
&ManifestJsonOptions {
@@ -325,7 +377,7 @@
};
let mut out = Vec::with_capacity(arr.len());
for i in arr.iter() {
- out.push(i.manifest(ty)?);
+ out.push(i?.manifest(ty)?);
}
Ok(out)
}
@@ -348,7 +400,7 @@
if !arr.is_empty() {
for v in arr.iter() {
out.push_str("---\n");
- out.push_str(&v.manifest(format)?);
+ out.push_str(&v?.manifest(format)?);
out.push('\n');
}
out.push_str("...");
@@ -456,7 +508,7 @@
/// Native implementation of `std.primitiveEquals`
pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {
- Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {
+ Ok(match (val_a, val_b) {
(Val::Bool(a), Val::Bool(b)) => a == b,
(Val::Null, Val::Null) => true,
(Val::Str(a), Val::Str(b)) => a == b,
@@ -476,10 +528,7 @@
/// Native implementation of `std.equals`
pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {
- let val_a = val_a.unwrap_if_lazy()?;
- let val_b = val_b.unwrap_if_lazy()?;
-
- if val_a.value_type()? != val_b.value_type()? {
+ if val_a.value_type() != val_b.value_type() {
return Ok(false);
}
match (val_a, val_b) {
@@ -489,7 +538,7 @@
return Ok(false);
}
for (a, b) in a.iter().zip(b.iter()) {
- if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {
+ if !equals(&a?, &b?)? {
return Ok(false);
}
}
crates/jrsonnet-parser/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -97,6 +97,7 @@
Mul,
Div,
+ /// Implemented as intrinsic, put here for completeness
Mod,
Add,