difftreelog
refact: simplify error management
in: master
18 files changed
bindings/jsonnet/src/import.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -1,7 +1,8 @@
//! Import resolution manipulation utilities
use jrsonnet_evaluator::{
- create_error, create_error_result, Error, EvaluationState, ImportResolver, Result,
+ error::{Error::*, Result},
+ throw, EvaluationState, ImportResolver,
};
use std::{
any::Any,
@@ -55,10 +56,9 @@
let result_str = result_raw.to_str().unwrap();
assert!(success == 0 || success == 1);
if success == 0 {
+ unsafe { CString::from_raw(result_ptr) };
let result = result_str.to_owned();
- let err = Err(create_error(Error::ImportCallbackError(result)));
- unsafe { CString::from_raw(result_ptr) };
- return err;
+ throw!(ImportCallbackError(result));
}
let found_here_raw = unsafe { CStr::from_ptr(found_here) };
@@ -121,15 +121,14 @@
return Ok(Rc::new(cloned));
}
}
- create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))
+ throw!(ImportFileNotFound(from.clone(), path.clone()))
}
}
fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
- let mut file =
- File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;
+ let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
let mut out = String::new();
file.read_to_string(&mut out)
- .map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;
+ .map_err(|_e| ImportBadFileUtf8(id.clone()))?;
Ok(out.into())
}
unsafe fn as_any(&self) -> &dyn Any {
cmds/jrsonnet/src/main.rsdiffbeforeafterboth--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -1,6 +1,6 @@
use clap::Clap;
use jrsonnet_cli::{ConfigureState, GeneralOpts, InputOpts, ManifestOpts};
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
use std::{path::PathBuf, rc::Rc};
#[global_allocator]
crates/jrsonnet-cli/src/ext.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/ext.rs
+++ b/crates/jrsonnet-cli/src/ext.rs
@@ -1,6 +1,6 @@
use crate::ConfigureState;
use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
use std::str::FromStr;
#[derive(Clone)]
crates/jrsonnet-cli/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -9,7 +9,7 @@
pub use trace::*;
use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, FileImportResolver, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState, FileImportResolver};
use std::path::PathBuf;
pub trait ConfigureState {
crates/jrsonnet-cli/src/manifest.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -1,6 +1,6 @@
use crate::ConfigureState;
use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState, ManifestFormat};
use std::str::FromStr;
pub enum ManifestFormatName {
crates/jrsonnet-cli/src/tla.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,6 +1,6 @@
use crate::{ConfigureState, ExtStr};
use clap::Clap;
-use jrsonnet_evaluator::{EvaluationState, Result};
+use jrsonnet_evaluator::{error::Result, EvaluationState};
#[derive(Clap)]
// #[clap(help_heading = "TOP LEVEL ARGUMENTS")]
crates/jrsonnet-cli/src/trace.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/trace.rs
+++ b/crates/jrsonnet-cli/src/trace.rs
@@ -1,8 +1,9 @@
use crate::ConfigureState;
use clap::Clap;
use jrsonnet_evaluator::{
+ error::Result,
trace::{CompactFormat, ExplainingFormat, PathResolver},
- EvaluationState, Result,
+ EvaluationState,
};
use std::str::FromStr;
crates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use crate::{5 create_error, create_error_result, to_string, Error, LocError, ObjValue, Val, ValType,6};78#[derive(Debug)]9pub enum FormatError {10 TruncatedFormatCode,11 UnrecognizedConversionType(char),12 ValueError(LocError),1314 NotEnoughValues,1516 CannotUseStarWidthWithObject,17 MappingKeysRequired,18 NoSuchField(Rc<str>),19}20impl From<LocError> for FormatError {21 fn from(e: LocError) -> Self {22 Self::ValueError(e)23 }24}25use std::rc::Rc;26use FormatError::*;2728pub fn try_parse_mapping_key(str: &str) -> Result<(&str, &str), FormatError> {29 if str.is_empty() {30 return Err(TruncatedFormatCode);31 }32 let bytes = str.as_bytes();33 if bytes[0] == b'(' {34 let mut i = 1;35 while i < bytes.len() {36 if bytes[i] == b')' {37 return Ok((&str[1..i as usize], &str[i as usize + 1..]));38 }39 i += 1;40 }41 Err(TruncatedFormatCode)42 } else {43 Ok(("", str))44 }45}4647#[cfg(test)]48pub mod tests_key {49 use super::*;5051 #[test]52 fn parse_key() {53 assert_eq!(54 try_parse_mapping_key("(hello ) world").unwrap(),55 ("hello ", " world")56 );57 assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));58 assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));59 assert_eq!(60 try_parse_mapping_key(" () world").unwrap(),61 ("", " () world")62 );63 }6465 #[test]66 #[should_panic]67 fn parse_key_missing_start() {68 try_parse_mapping_key("").unwrap();69 }7071 #[test]72 #[should_panic]73 fn parse_key_missing_end() {74 try_parse_mapping_key("( ").unwrap();75 }76}7778#[derive(Default, Debug)]79pub struct CFlags {80 pub alt: bool,81 pub zero: bool,82 pub left: bool,83 pub blank: bool,84 pub sign: bool,85}8687pub fn try_parse_cflags(str: &str) -> Result<(CFlags, &str), FormatError> {88 if str.is_empty() {89 return Err(TruncatedFormatCode);90 }91 let bytes = str.as_bytes();92 let mut i = 0;93 let mut out = CFlags::default();94 loop {95 if bytes.len() == i {96 return Err(TruncatedFormatCode);97 }98 match bytes[i] {99 b'#' => out.alt = true,100 b'0' => out.zero = true,101 b'-' => out.left = true,102 b' ' => out.blank = true,103 b'+' => out.sign = true,104 _ => break,105 }106 i += 1;107 }108 Ok((out, &str[i..]))109}110111#[derive(Debug, PartialEq)]112pub enum Width {113 Star,114 Fixed(usize),115}116pub fn try_parse_field_width(str: &str) -> Result<(Width, &str), FormatError> {117 if str.is_empty() {118 return Err(TruncatedFormatCode);119 }120 let bytes = str.as_bytes();121 if bytes[0] == b'*' {122 return Ok((Width::Star, &str[1..]));123 }124 let mut out: usize = 0;125 let mut digits = 0;126 while let Some(digit) = (bytes[digits] as char).to_digit(10) {127 out *= 10;128 out += digit as usize;129 digits += 1;130 if digits == bytes.len() {131 return Err(TruncatedFormatCode);132 }133 }134 Ok((Width::Fixed(out), &str[digits..]))135}136137pub fn try_parse_precision(str: &str) -> Result<(Option<Width>, &str), FormatError> {138 if str.is_empty() {139 return Err(TruncatedFormatCode);140 }141 let bytes = str.as_bytes();142 if bytes[0] == b'.' {143 try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))144 } else {145 Ok((None, str))146 }147}148149// Only skips150pub fn try_parse_length_modifier(str: &str) -> Result<&str, FormatError> {151 if str.is_empty() {152 return Err(TruncatedFormatCode);153 }154 let bytes = str.as_bytes();155 let mut idx = 0;156 while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {157 idx += 1;158 if bytes.len() == idx {159 return Err(TruncatedFormatCode);160 }161 }162 Ok(&str[idx..])163}164165#[derive(Debug)]166pub enum ConvTypeV {167 Decimal,168 Octal,169 Hexadecimal,170 Scientific,171 Float,172 Shorter,173 Char,174 String,175 Percent,176}177pub struct ConvType {178 v: ConvTypeV,179 caps: bool,180}181182pub fn parse_conversion_type(str: &str) -> Result<(ConvType, &str), FormatError> {183 if str.is_empty() {184 return Err(TruncatedFormatCode);185 }186187 let code = str.as_bytes()[0];188 let v: (ConvTypeV, bool) = match code {189 b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),190 b'o' => (ConvTypeV::Octal, false),191 b'x' => (ConvTypeV::Hexadecimal, false),192 b'X' => (ConvTypeV::Hexadecimal, true),193 b'e' => (ConvTypeV::Scientific, false),194 b'E' => (ConvTypeV::Scientific, true),195 b'f' => (ConvTypeV::Float, false),196 b'F' => (ConvTypeV::Float, true),197 b'g' => (ConvTypeV::Shorter, false),198 b'G' => (ConvTypeV::Shorter, true),199 b'c' => (ConvTypeV::Char, false),200 b's' => (ConvTypeV::String, false),201 b'%' => (ConvTypeV::Percent, false),202 c => return Err(UnrecognizedConversionType(c as char)),203 };204205 Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))206}207208#[derive(Debug)]209pub struct Code<'s> {210 mkey: &'s str,211 cflags: CFlags,212 width: Width,213 precision: Option<Width>,214 convtype: ConvTypeV,215 caps: bool,216}217pub fn parse_code(str: &str) -> Result<(Code, &str), FormatError> {218 if str.is_empty() {219 return Err(TruncatedFormatCode);220 }221 let (mkey, str) = try_parse_mapping_key(str)?;222 let (cflags, str) = try_parse_cflags(str)?;223 let (width, str) = try_parse_field_width(str)?;224 let (precision, str) = try_parse_precision(str)?;225 let str = try_parse_length_modifier(str)?;226 let (convtype, str) = parse_conversion_type(str)?;227228 Ok((229 Code {230 mkey,231 cflags,232 width,233 precision,234 convtype: convtype.v,235 caps: convtype.caps,236 },237 str,238 ))239}240241#[derive(Debug)]242pub enum Element<'s> {243 String(&'s str),244 Code(Code<'s>),245}246pub fn parse_codes(mut str: &str) -> Result<Vec<Element>, FormatError> {247 let mut bytes = str.as_bytes();248 let mut out = vec![];249 let mut offset = 0;250251 loop {252 while offset != bytes.len() && bytes[offset] != b'%' {253 offset += 1;254 }255 if offset != 0 {256 out.push(Element::String(&str[0..offset]));257 }258 if offset == bytes.len() {259 return Ok(out);260 }261 str = &str[offset + 1..];262 let (code, nstr) = parse_code(str)?;263 str = nstr;264 bytes = str.as_bytes();265 offset = 0;266267 out.push(Element::Code(code))268 }269}270271const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";272273#[inline]274pub fn render_integer(275 out: &mut String,276 iv: i64,277 padding: usize,278 precision: usize,279 blank: bool,280 sign: bool,281 radix: i64,282 prefix: &str,283 caps: bool,284) {285 // Digit char indexes in reverse order, i.e286 // for radix = 16 and n = 12f: [15, 2, 1]287 let digits = if iv == 0 {288 vec![0u8]289 } else {290 let mut v = iv.abs();291 let mut nums = Vec::with_capacity(1);292 while v > 0 {293 nums.push((v % radix) as u8);294 v /= radix;295 }296 nums297 };298 let neg = iv < 0;299 let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });300 let zp2 = zp301 .max(precision)302 .saturating_sub(prefix.len() + digits.len());303304 if neg {305 out.push('-')306 } else if sign {307 out.push('+');308 } else if blank {309 out.push(' ');310 }311312 out.reserve(zp2);313 for _ in 0..zp2 {314 out.push('0');315 }316 out.push_str(&prefix);317318 for digit in digits.into_iter().rev() {319 let ch = NUMBERS[digit as usize] as char;320 out.push(if caps { ch.to_ascii_uppercase() } else { ch });321 }322}323324pub fn render_decimal(325 out: &mut String,326 iv: i64,327 padding: usize,328 precision: usize,329 blank: bool,330 sign: bool,331) {332 render_integer(out, iv, padding, precision, blank, sign, 10, "", false)333}334pub fn render_octal(335 out: &mut String,336 iv: i64,337 padding: usize,338 precision: usize,339 alt: bool,340 blank: bool,341 sign: bool,342) {343 render_integer(344 out,345 iv,346 padding,347 precision,348 blank,349 sign,350 8,351 if alt && iv != 0 { "0" } else { "" },352 false,353 )354}355pub fn render_hexadecimal(356 out: &mut String,357 iv: i64,358 padding: usize,359 precision: usize,360 alt: bool,361 blank: bool,362 sign: bool,363 caps: bool,364) {365 render_integer(366 out,367 iv,368 padding,369 precision,370 blank,371 sign,372 16,373 match (alt, caps) {374 (true, true) => "0X",375 (true, false) => "0x",376 (false, _) => "",377 },378 caps,379 )380}381382pub fn render_float(383 out: &mut String,384 n: f64,385 mut padding: usize,386 precision: usize,387 blank: bool,388 sign: bool,389 ensure_pt: bool,390 trailing: bool,391) {392 let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };393 padding = padding.saturating_sub(dot_size + precision);394 render_decimal(out, n.floor() as i64, padding, 0, blank, sign);395 if precision == 0 {396 if ensure_pt {397 out.push('.');398 }399 return;400 }401 let frac = (n.fract() * 10.0_f64.powf(precision as f64) + 0.5).floor();402 if trailing || frac > 0.0 {403 out.push('.');404 let mut frac_str = String::new();405 render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);406 let mut trim = frac_str.len();407 if !trailing {408 for b in frac_str.as_bytes().iter().rev() {409 if *b == b'0' {410 trim -= 1;411 }412 }413 }414 out.push_str(&frac_str[..trim]);415 } else if ensure_pt {416 out.push('.');417 }418}419420pub fn render_float_sci(421 out: &mut String,422 n: f64,423 mut padding: usize,424 precision: usize,425 blank: bool,426 sign: bool,427 ensure_pt: bool,428 trailing: bool,429 caps: bool,430) {431 let exponent = n.log10().floor();432 let mantissa = if exponent as i16 == -324 {433 n * 10.0 / 10.0_f64.powf(exponent + 1.0)434 } else {435 n / 10.0_f64.powf(exponent)436 };437 let mut exponent_str = String::new();438 render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);439440 // +1 for e441 padding = padding.saturating_sub(exponent_str.len() + 1);442443 render_float(444 out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,445 );446 out.push(if caps { 'E' } else { 'e' });447 out.push_str(&exponent_str);448}449450pub fn format_code(451 out: &mut String,452 value: &Val,453 code: &Code,454 width: usize,455 precision: Option<usize>,456) -> Result<(), FormatError> {457 let clfags = &code.cflags;458 let (fpprec, iprec) = match precision {459 Some(v) => (v, v),460 None => (6, 0),461 };462 let padding = if clfags.zero && !clfags.left {463 width464 } else {465 0466 };467468 // TODO: If left padded, can optimize by writing directly to out469 let mut tmp_out = String::new();470471 match code.convtype {472 ConvTypeV::String => tmp_out.push_str(&to_string(value)?),473 ConvTypeV::Decimal => {474 let value = value.clone().try_cast_num("%d/%u/%i requires number")?;475 render_decimal(476 &mut tmp_out,477 value as i64,478 padding,479 iprec,480 clfags.blank,481 clfags.sign,482 );483 }484 ConvTypeV::Octal => {485 let value = value.clone().try_cast_num("%o requires number")?;486 render_octal(487 &mut tmp_out,488 value as i64,489 padding,490 iprec,491 clfags.alt,492 clfags.blank,493 clfags.sign,494 );495 }496 ConvTypeV::Hexadecimal => {497 let value = value.clone().try_cast_num("%x/%X requires number")?;498 render_hexadecimal(499 &mut tmp_out,500 value as i64,501 padding,502 iprec,503 clfags.alt,504 clfags.blank,505 clfags.sign,506 code.caps,507 );508 }509 ConvTypeV::Scientific => {510 let value = value.clone().try_cast_num("%e/%E requires number")?;511 render_float_sci(512 &mut tmp_out,513 value,514 padding,515 fpprec,516 clfags.blank,517 clfags.sign,518 clfags.alt,519 true,520 code.caps,521 );522 }523 ConvTypeV::Float => {524 let value = value.clone().try_cast_num("%e/%E requires number")?;525 render_float(526 &mut tmp_out,527 value,528 padding,529 fpprec,530 clfags.blank,531 clfags.sign,532 clfags.alt,533 true,534 );535 }536 ConvTypeV::Shorter => {537 let value = value.clone().try_cast_num("%g/%G requires number")?;538 let exponent = value.log10().floor();539 if exponent < -4.0 || exponent >= fpprec as f64 {540 render_float_sci(541 &mut tmp_out,542 value,543 padding,544 fpprec - 1,545 clfags.blank,546 clfags.sign,547 clfags.alt,548 clfags.alt,549 code.caps,550 );551 } else {552 let digits_before_pt = 1.max(exponent as usize + 1);553 render_float(554 &mut tmp_out,555 value,556 padding,557 fpprec - digits_before_pt,558 clfags.blank,559 clfags.sign,560 clfags.alt,561 clfags.alt,562 );563 }564 }565 ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {566 Val::Num(n) => tmp_out.push(567 std::char::from_u32(n as u32)568 .ok_or_else(|| create_error(Error::InvalidUnicodeCodepointGot(n as u32)))?,569 ),570 Val::Str(s) => {571 if s.chars().count() != 1 {572 create_error_result(Error::RuntimeError(573 format!("%c expected 1 char string, got {}", s.chars().count()).into(),574 ))?;575 }576 tmp_out.push_str(&s);577 }578 _ => {579 create_error_result(Error::TypeMismatch(580 "%c requires number/string",581 vec![ValType::Num, ValType::Str],582 value.value_type()?,583 ))?;584 }585 },586 ConvTypeV::Percent => tmp_out.push('%'),587 };588589 let padding = width.saturating_sub(tmp_out.len());590591 if !clfags.left {592 for _ in 0..padding {593 out.push(' ');594 }595 }596 out.push_str(&tmp_out);597 if clfags.left {598 for _ in 0..padding {599 out.push(' ');600 }601 }602603 Ok(())604}605606pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String, FormatError> {607 let codes = parse_codes(&str)?;608 let mut out = String::new();609610 for code in codes {611 match code {612 Element::String(s) => {613 out.push_str(s);614 }615 Element::Code(c) => {616 let width = match c.width {617 Width::Star => {618 if values.is_empty() {619 return Err(FormatError::NotEnoughValues);620 }621 let value = &values[0];622 values = &values[1..];623 value.clone().try_cast_num("field width")? as usize624 }625 Width::Fixed(n) => n,626 };627 let precision = match c.precision {628 Some(Width::Star) => {629 if values.is_empty() {630 return Err(FormatError::NotEnoughValues);631 }632 let value = &values[0];633 values = &values[1..];634 Some(value.clone().try_cast_num("field precision")? as usize)635 }636 Some(Width::Fixed(n)) => Some(n),637 None => None,638 };639640 // %% should not consume a value641 let value = if c.convtype == ConvTypeV::Percent {642 &Val::Null643 } else {644 if values.is_empty() {645 return Err(FormatError::NotEnoughValues);646 }647 let value = &values[0];648 values = &values[1..];649 value650 };651652 format_code(&mut out, value, &c, width, precision)?;653 }654 }655 }656657 Ok(out)658}659660pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {661 let codes = parse_codes(&str)?;662 let mut out = String::new();663664 for code in codes {665 match code {666 Element::String(s) => {667 out.push_str(s);668 }669 Element::Code(c) => {670 // TODO: Operate on ref671 let f: Rc<str> = c.mkey.into();672 if f.is_empty() {673 return Err(FormatError::MappingKeysRequired);674 }675 let width = match c.width {676 Width::Star => {677 return Err(FormatError::CannotUseStarWidthWithObject);678 }679 Width::Fixed(n) => n,680 };681 let precision = match c.precision {682 Some(Width::Star) => {683 return Err(FormatError::CannotUseStarWidthWithObject);684 }685 Some(Width::Fixed(n)) => Some(n),686 None => None,687 };688 let value = if let Some(v) = values.get(f.clone())? {689 v690 } else {691 return Err(FormatError::NoSuchField(f));692 };693694 format_code(&mut out, &value, &c, width, precision)?;695 }696 }697 }698699 Ok(out)700}701702#[cfg(test)]703pub mod test_format {704 use super::*;705706 #[test]707 fn parse() {708 assert_eq!(709 parse_codes(710 "How much error budget is left looking at our %.3f%% availability gurantees?"711 )712 .unwrap()713 .len(),714 4715 );716 }717718 #[test]719 fn octals() {720 assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");721 assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");722 assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), " 10");723 assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");724 assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");725 assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");726 assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10 ");727 assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");728 assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");729 }730731 #[test]732 fn percent_doesnt_consumes_values() {733 assert_eq!(734 format_arr(735 "How much error budget is left looking at our %.3f%% availability gurantees?",736 &[Val::Num(4.0)]737 )738 .unwrap(),739 "How much error budget is left looking at our 4.000% availability gurantees?"740 );741 }742}crates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -1,5 +1,5 @@
use crate::{
- create_error, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val, Error,
+ error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,
LazyBinding, LazyVal, ObjValue, Result, Val,
};
use std::{
@@ -61,11 +61,12 @@
}
pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {
- self.0
+ Ok(self
+ .0
.bindings
.get(&name)
.cloned()
- .ok_or_else(|| create_error(Error::UnknownVariable(name)))
+ .ok_or_else(|| UnknownVariable(name))?)
}
pub fn into_future(self, ctx: FutureContext) -> Context {
{
crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -1,4 +1,4 @@
-use crate::{Val, ValType};
+use crate::{builtin::format::FormatError, Val, ValType};
use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
use std::{path::PathBuf, rc::Rc};
@@ -61,7 +61,14 @@
ImportCallbackError(String),
InvalidUnicodeCodepointGot(u32),
+
+ Format(FormatError),
}
+impl From<Error> for LocError {
+ fn from(e: Error) -> Self {
+ Self(e, StackTrace(vec![]))
+ }
+}
#[derive(Clone, Debug)]
pub struct StackTraceElement {
@@ -73,4 +80,17 @@
#[derive(Debug, Clone)]
pub struct LocError(pub Error, pub StackTrace);
+impl LocError {
+ pub fn new(e: Error) -> Self {
+ Self(e, StackTrace(vec![]))
+ }
+}
+
pub type Result<V> = std::result::Result<V, LocError>;
+
+#[macro_export]
+macro_rules! throw {
+ ($e: expr) => {
+ return Err($e.into());
+ };
+}
crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -1,9 +1,10 @@
use crate::{
builtin::format::{format_arr, format_obj},
- context_creator, create_error, create_error_result, equals, escape_string_json, future_wrapper,
- lazy_val, manifest_json_ex, parse_args, primitive_equals, push, with_state, Context,
- ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,
- ValType,
+ context_creator, equals,
+ error::Error::*,
+ escape_string_json, future_wrapper, lazy_val, manifest_json_ex, parse_args, primitive_equals,
+ push, throw, with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError,
+ ObjMember, ObjValue, Result, Val, ValType,
};
use closure::closure;
use jrsonnet_parser::{
@@ -11,7 +12,7 @@
ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
Visibility,
};
-use std::{cmp::Ordering, collections::HashMap, rc::Rc};
+use std::{cmp::Ordering, collections::HashMap, path::PathBuf, rc::Rc};
pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {
let b = b.clone();
@@ -79,10 +80,7 @@
(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) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(
- op,
- o.value_type()?,
- ))?,
+ (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),
})
}
@@ -100,11 +98,11 @@
(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::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,
- _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(
+ _ => throw!(BinaryOperatorDoesNotOperateOnValues(
BinaryOpType::Add,
a.value_type()?,
b.value_type()?,
- ))?,
+ )),
})
}
@@ -145,7 +143,7 @@
(Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,
(Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {
if *v2 <= f64::EPSILON {
- create_error_result(crate::Error::DivisionByZero)?
+ throw!(DivisionByZero)
}
Val::new_checked_num(v1 / v2)?
}
@@ -168,22 +166,22 @@
}
(Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {
if *v2 < 0.0 {
- create_error_result(Error::RuntimeError("shift by negative exponent".into()))?
+ throw!(RuntimeError("shift by negative exponent".into()))
}
Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)
}
(Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {
if *v2 < 0.0 {
- create_error_result(Error::RuntimeError("shift by negative exponent".into()))?
+ throw!(RuntimeError("shift by negative exponent".into()))
}
Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)
}
- _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(
+ _ => throw!(BinaryOperatorDoesNotOperateOnValues(
op,
a.value_type()?,
b.value_type()?,
- ))?,
+ )),
})
}
@@ -218,7 +216,7 @@
}
Some(out.into_iter().flatten().flatten().collect())
}
- _ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,
+ _ => throw!(InComprehensionCanOnlyIterateOverArray),
}
}
})
@@ -379,7 +377,7 @@
},
);
}
- v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,
+ v => throw!(FieldMustBeStringGot(v.value_type()?)),
}
}
@@ -409,7 +407,7 @@
Ok(match value {
Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {
// arr/string/function
- ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [
+ ("std", "length") => parse_args!(context, "std.length", args, 1, [
0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];
], {
Ok(match x {
@@ -423,20 +421,20 @@
),
_ => unreachable!(),
})
- }))?,
+ })?,
// any
("std", "type") => parse_args!(context, "std.type", args, 1, [
0, x, vec![];
], {
- Val::Str(x.value_type()?.name().into())
- }),
+ Ok(Val::Str(x.value_type()?.name().into()))
+ })?,
// length, idx=>any
("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [
0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];
1, func: [Val::Func]!!Val::Func, vec![ValType::Func];
], {
if sz < 0.0 {
- create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;
+ throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));
}
let mut out = Vec::with_capacity(sz as usize);
for i in 0..sz as usize {
@@ -455,8 +453,8 @@
str.chars().count() == 1,
"std.codepoint should receive single char string"
);
- Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)
- }),
+ Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))
+ })?,
// object, includeHidden
("std", "objectFieldsEx") => {
noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [
@@ -478,42 +476,42 @@
1, f: [Val::Str]!!Val::Str, vec![ValType::Str];
2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];
], {
- Val::Bool(
+ Ok(Val::Bool(
obj.fields_visibility()
.into_iter()
.filter(|(_k, v)| *v || inc_hidden)
.any(|(k, _v)| *k == *f),
- )
- }),
+ ))
+ })?,
("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [
0, a, vec![];
1, b, vec![];
], {
- Val::Bool(primitive_equals(&a, &b)?)
- }),
+ Ok(Val::Bool(primitive_equals(&a, &b)?))
+ })?,
// faster
("std", "equals") => parse_args!(context, "std.equals", args, 2, [
0, a, vec![];
1, b, vec![];
], {
- Val::Bool(equals(&a, &b)?)
- }),
+ Ok(Val::Bool(equals(&a, &b)?))
+ })?,
("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [
0, a: [Val::Num]!!Val::Num, vec![ValType::Num];
1, b: [Val::Num]!!Val::Num, vec![ValType::Num];
], {
- Val::Num(a % b)
- }),
+ Ok(Val::Num(a % b))
+ })?,
("std", "floor") => parse_args!(context, "std.floor", args, 1, [
0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
], {
- Val::Num(x.floor())
- }),
+ Ok(Val::Num(x.floor()))
+ })?,
("std", "log") => parse_args!(context, "std.log", args, 2, [
0, n: [Val::Num]!!Val::Num, vec![ValType::Num];
], {
- Val::Num(n.ln())
- }),
+ Ok(Val::Num(n.ln()))
+ })?,
("std", "trace") => parse_args!(context, "std.trace", args, 2, [
0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
1, rest, vec![];
@@ -526,21 +524,21 @@
});
}
eprintln!(" {}", str);
- rest
- }),
+ Ok(rest)
+ })?,
("std", "pow") => parse_args!(context, "std.modulo", args, 2, [
0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
1, n: [Val::Num]!!Val::Num, vec![ValType::Num];
], {
- Val::Num(x.powf(n))
- }),
+ Ok(Val::Num(x.powf(n)))
+ })?,
("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [
0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
], {
- with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(
- || create_error(crate::Error::UndefinedExternalVariable(x)),
- )?
- }),
+ Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(
+ || UndefinedExternalVariable(x),
+ )?)
+ })?,
("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [
0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
@@ -583,6 +581,7 @@
Ok(acc)
}))?,
// faster
+ #[allow(non_snake_case)]
("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [
0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];
@@ -598,7 +597,7 @@
match keyF.evaluate_values(context.clone(), &[k.clone()]) {
Ok(Val::Str(v)) => v,
Ok(_) => {
- err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));
+ err = Some(LocError::new(RuntimeError("types of all array elements should equal".into())));
"".into()
}
Err(e) => {
@@ -617,7 +616,7 @@
match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {
(Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),
(Ok(_a), Ok(_b)) => {
- err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));
+ err = Some(RuntimeError("types of all array elements should equal".into()).into());
Ordering::Equal
}
(Err(e), _) | (_, Err(e)) => {
@@ -630,21 +629,23 @@
return Err(e);
}
},
- _ => return Err(create_error(crate::error::Error::RuntimeError("keys should be number or string".into())))
+ _ => throw!(RuntimeError("keys should be number or string".into()))
}
Ok(Val::Arr(Rc::new(new_arr)))
}))?,
// faster
("std", "format") => parse_args!(context, "std.format", args, 2, [
0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
- 1, vals: [Val::Arr|Val::Obj], vec![ValType::Arr, ValType::Obj];
+ 1, vals, vec![]
], {
- match vals {
- Val::Arr(vals) => Val::Str(format_arr(&str, &vals).unwrap().into()),
- Val::Obj(obj) => Val::Str(format_obj(&str, &obj).unwrap().into()),
- _ => unreachable!()
- }
- }),
+ push(&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)), ||format!("std.format of {}", str), ||{
+ Ok(match vals {
+ Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),
+ Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),
+ o => Val::Str(format_arr(&str, &[o])?.into()),
+ })
+ })
+ })?,
// faster
("std", "range") => parse_args!(context, "std.range", args, 2, [
0, from: [Val::Num]!!Val::Num, vec![ValType::Num];
@@ -654,22 +655,22 @@
for i in from as usize..=to as usize {
out.push(Val::Num(i as f64));
}
- Val::Arr(Rc::new(out))
- }),
+ Ok(Val::Arr(Rc::new(out)))
+ })?,
("std", "char") => parse_args!(context, "std.char", args, 1, [
0, n: [Val::Num]!!Val::Num, vec![ValType::Num];
], {
let mut out = String::new();
out.push(std::char::from_u32(n as u32).ok_or_else(||
- create_error(crate::error::Error::InvalidUnicodeCodepointGot(n as u32))
+ InvalidUnicodeCodepointGot(n as u32)
)?);
Ok(Val::Str(out.into()))
})?,
("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [
0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
], {
- Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))
- }),
+ Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))
+ })?,
("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [
0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
], {
@@ -679,7 +680,7 @@
("std", "base64") => parse_args!(context, "std.base64", args, 1, [
0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];
], {
- Val::Str(match input {
+ Ok(Val::Str(match input {
Val::Str(s) => {
base64::encode(s.bytes().collect::<Vec<_>>()).into()
},
@@ -689,8 +690,8 @@
}).collect::<Result<Vec<_>>>()?).into()
},
_ => unreachable!()
- })
- }),
+ }))
+ })?,
// faster
("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [
0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];
@@ -711,7 +712,7 @@
out.reserve(items.len());
out.extend(items.iter().cloned());
} else {
- create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;
+ throw!(RuntimeError("in std.join all items should be arrays".into()));
}
}
@@ -729,7 +730,7 @@
first = false;
out += &item;
} else {
- create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;
+ throw!(RuntimeError("in std.join all items should be strings".into()));
}
}
@@ -742,18 +743,16 @@
("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [
0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];
], {
- Val::Str(escape_string_json(&str_).into())
- }),
+ Ok(Val::Str(escape_string_json(&str_).into()))
+ })?,
// Faster
("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [
0, value, vec![];
1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];
], {
- Val::Str(manifest_json_ex(&value, &indent)?.into())
- }),
- (ns, name) => {
- create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?
- }
+ Ok(Val::Str(manifest_json_ex(&value, &indent)?.into()))
+ })?,
+ (ns, name) => throw!(IntristicNotFound(ns.into(), name.into())),
},
Val::Func(f) => {
let body = || f.evaluate(context, args, tailstrict);
@@ -763,7 +762,7 @@
push(loc, || format!("function <{}> call", f.name), body)?
}
}
- v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,
+ v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),
})
}
@@ -784,13 +783,13 @@
context
.this()
.clone()
- .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,
+ .ok_or_else(|| CantUseSelfOutsideOfObject)?,
),
Literal(LiteralType::Dollar) => Val::Obj(
context
.dollar()
.clone()
- .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,
+ .ok_or_else(|| NoTopLevelObjectFound)?,
),
Literal(LiteralType::True) => Val::Bool(true),
Literal(LiteralType::False) => Val::Bool(false),
@@ -825,34 +824,30 @@
} else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {
Val::Intristic(n, s)
} else {
- create_error_result(crate::Error::NoSuchField(s))?
+ throw!(NoSuchField(s))
}
}
- (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(
+ (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Obj,
ValType::Str,
n.value_type()?,
- ))?,
+ )),
(Val::Arr(v), Val::Num(n)) => {
if n.fract() > f64::EPSILON {
- create_error_result(crate::Error::FractionalIndex)?
+ throw!(FractionalIndex)
}
v.get(n as usize)
- .ok_or_else(|| {
- create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))
- })?
+ .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
.clone()
.unwrap_if_lazy()?
- }
- (Val::Arr(_), Val::Str(n)) => {
- create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?
}
- (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(
+ (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),
+ (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Arr,
ValType::Num,
n.value_type()?,
- ))?,
+ )),
(Val::Str(s), Val::Num(n)) => Val::Str(
s.chars()
@@ -861,13 +856,13 @@
.collect::<String>()
.into(),
),
- (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(
+ (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
ValType::Str,
ValType::Num,
n.value_type()?,
- ))?,
+ )),
- (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,
+ (v, _) => throw!(CantIndexInto(v.value_type()?)),
}
}
LocalExpr(bindings, returned) => {
@@ -926,18 +921,18 @@
if assertion_result {
evaluate(context, returned)?
} else if let Some(msg) = msg {
- create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?
+ throw!(AssertionFailed(evaluate(context, msg)?));
} else {
- create_error_result(crate::Error::AssertionFailed(Val::Null))?
+ throw!(AssertionFailed(Val::Null));
}
}
- Error(e) => push(
+ ErrorStmt(e) => push(
&loc,
|| "error statement".to_owned(),
|| {
- create_error_result(crate::Error::RuntimeError(
+ throw!(RuntimeError(
evaluate(context, e)?.try_cast_str("error text should be string")?,
- ))?
+ ))
},
)?,
IfElse {
@@ -978,6 +973,6 @@
import_location.pop();
Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)
}
- Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),
+ Literal(LiteralType::Super) => throw!(StandaloneSuper),
})
}
crates/jrsonnet-evaluator/src/function.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -1,7 +1,4 @@
-use crate::{
- create_error, create_error_result, evaluate, lazy_val, resolved_lazy_val, Context, Error,
- Result, Val,
-};
+use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};
use closure::closure;
use jrsonnet_parser::{ArgsDesc, ParamsDesc};
use std::{collections::HashMap, rc::Rc};
@@ -30,16 +27,16 @@
params
.iter()
.position(|p| *p.0 == *name)
- .ok_or_else(|| create_error(Error::UnknownFunctionParameter(name.clone())))?
+ .ok_or_else(|| UnknownFunctionParameter(name.clone()))?
} else {
id
};
if idx >= params.len() {
- create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+ throw!(TooManyArgsFunctionHas(params.len()));
}
if positioned_args[idx].is_some() {
- create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;
+ throw!(BindingParameterASecondTime(params[idx].0.clone()));
}
positioned_args[idx] = Some(arg.1.clone());
}
@@ -50,8 +47,7 @@
} else if let Some(default) = &p.1 {
(body_ctx.clone().expect(NO_DEFAULT_CONTEXT), default)
} else {
- create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
- unreachable!()
+ throw!(FunctionParameterNotBoundInCall(p.0.clone()));
};
let val = if tailstrict {
resolved_lazy_val!(evaluate(ctx, expr)?)
@@ -74,15 +70,16 @@
let mut out = HashMap::new();
let mut positioned_args = vec![None; params.0.len()];
for (name, val) in args.iter() {
- let idx = params.iter().position(|p| *p.0 == **name).ok_or_else(|| {
- create_error(Error::UnknownFunctionParameter((&name as &str).to_owned()))
- })?;
+ let idx = params
+ .iter()
+ .position(|p| *p.0 == **name)
+ .ok_or_else(|| UnknownFunctionParameter((&name as &str).to_owned()))?;
if idx >= params.len() {
- create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+ throw!(TooManyArgsFunctionHas(params.len()));
}
if positioned_args[idx].is_some() {
- create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;
+ throw!(BindingParameterASecondTime(params[idx].0.clone()));
}
positioned_args[idx] = Some(val.clone());
}
@@ -104,8 +101,7 @@
})
}
} else {
- create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
- unreachable!()
+ throw!(FunctionParameterNotBoundInCall(p.0.clone()));
};
out.insert(p.0.clone(), val);
}
@@ -123,7 +119,7 @@
let mut positioned_args = vec![None; params.0.len()];
for (id, arg) in args.iter().enumerate() {
if id >= params.len() {
- create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;
+ throw!(TooManyArgsFunctionHas(params.len()));
}
positioned_args[id] = Some(arg);
}
@@ -134,8 +130,7 @@
} else if let Some(default) = &p.1 {
evaluate(ctx.clone(), default)?
} else {
- create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;
- unreachable!()
+ throw!(FunctionParameterNotBoundInCall(p.0.clone()));
};
out.insert(p.0.clone(), resolved_lazy_val!(val));
}
@@ -148,36 +143,39 @@
($ctx: expr, $fn_name: expr, $args: expr, $total_args: expr, [
$($id: expr, $name: ident $(: [$($p: path)|+] $(!! $a: path)?)?, $nt: expr);+ $(;)?
], $handler:block) => {{
- use crate::Error;
+ use crate::{throw, error::Error::*};
let args = $args;
if args.len() > $total_args {
- create_error_result(Error::TooManyArgsFunctionHas($total_args))?;
+ throw!(TooManyArgsFunctionHas($total_args));
}
$(
if args.len() <= $id {
- create_error_result(Error::FunctionParameterNotBoundInCall(stringify!($name).into()))?;
+ throw!(FunctionParameterNotBoundInCall(stringify!($name).into()));
}
let $name = &args[$id];
if $name.0.is_some() {
if $name.0.as_ref().unwrap() != stringify!($name) {
- create_error_result(Error::IntristicArgumentReorderingIsNotSupportedYet)?;
+ throw!(IntristicArgumentReorderingIsNotSupportedYet);
}
}
let $name = evaluate($ctx.clone(), &$name.1)?;
$(
match $name {
$($p(_))|+ => {},
- _ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,
+ _ => throw!(TypeMismatch(
+ concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"),
+ $nt, $name.value_type()?
+ )),
};
$(
let $name = match $name {
$a(v) => v,
- _ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,
+ _ =>throw!(TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?)),
};
)*
)*
)+
- $handler
+ ($handler as crate::Result<_>)
}};
}
@@ -198,7 +196,9 @@
], {
assert!((a - 2.0).abs() <= f64::EPSILON);
assert!((b - 1.0).abs() <= f64::EPSILON);
- });
+ Ok(())
+ })
+ .unwrap();
Ok(())
})
}
crates/jrsonnet-evaluator/src/import.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -1,7 +1,6 @@
-use crate::create_error_result;
use crate::{
- create_error,
- error::{Error, Result},
+ error::{Error::*, Result},
+ throw,
};
use fs::File;
use std::fs;
@@ -28,7 +27,7 @@
pub struct DummyImportResolver;
impl ImportResolver for DummyImportResolver {
fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
- create_error_result(Error::ImportNotSupported(from.clone(), path.clone()))
+ throw!(ImportNotSupported(from.clone(), path.clone()))
}
fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {
// Can be only caused by library direct consumer, not by supplied jsonnet
@@ -65,15 +64,14 @@
return Ok(Rc::new(cloned));
}
}
- create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))
+ throw!(ImportFileNotFound(from.clone(), path.clone()))
}
}
fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
- let mut file =
- File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;
+ let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
let mut out = String::new();
file.read_to_string(&mut out)
- .map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;
+ .map_err(|_e| ImportBadFileUtf8(id.clone()))?;
Ok(out.into())
}
unsafe fn as_any(&self) -> &dyn Any {
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -10,7 +10,7 @@
mod builtin;
mod ctx;
mod dynamic;
-mod error;
+pub mod error;
mod evaluate;
mod function;
mod import;
@@ -21,7 +21,7 @@
pub use ctx::*;
pub use dynamic::*;
-pub use error::*;
+use error::{Error::*, LocError, Result, StackTraceElement};
pub use evaluate::*;
pub use function::parse_function_call;
pub use import::*;
@@ -131,13 +131,7 @@
}
pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {
EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))
-}
-pub fn create_error(err: Error) -> LocError {
- LocError(err, StackTrace(vec![]))
}
-pub fn create_error_result<T>(err: Error) -> Result<T> {
- Err(LocError(err, StackTrace(vec![])))
-}
pub(crate) fn push<T>(
e: &Option<ExprLocation>,
frame_desc: impl FnOnce() -> String,
@@ -167,12 +161,10 @@
loc_data: true,
},
)
- .map_err(|error| {
- create_error(Error::ImportSyntaxError {
- error,
- path,
- source_code,
- })
+ .map_err(|error| ImportSyntaxError {
+ error,
+ path,
+ source_code,
})?,
)?;
@@ -292,7 +284,7 @@
if *stack_depth > self.max_stack() {
// Error creation uses data, so i drop guard here
drop(data);
- return Err(create_error(Error::StackOverflow));
+ throw!(StackOverflow);
} else {
*stack_depth += 1;
}
@@ -340,7 +332,7 @@
ManifestFormat::Json(padding) => val.into_json(padding)?,
ManifestFormat::None => match val {
Val::Str(s) => s,
- _ => return Err(create_error(Error::StringManifestOutputIsNotAString)),
+ _ => throw!(StringManifestOutputIsNotAString),
},
})
})
@@ -476,7 +468,7 @@
#[cfg(test)]
pub mod tests {
use super::Val;
- use crate::{create_error, primitive_equals, EvaluationState};
+ use crate::{error::Error::*, primitive_equals, EvaluationState};
use jrsonnet_parser::*;
use std::{path::PathBuf, rc::Rc};
@@ -493,7 +485,7 @@
state.push(
&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
|| "inner".to_owned(),
- || Err(create_error(crate::error::Error::RuntimeError("".into()))),
+ || Err(RuntimeError("".into()).into()),
)?;
Ok(())
},
crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -11,11 +11,13 @@
pub location: Option<ExprLocation>,
}
+// Field => This
+type CacheKey = (Rc<str>, usize);
#[derive(Debug)]
pub struct ObjValueInternals {
super_obj: Option<ObjValue>,
this_entries: Rc<HashMap<Rc<str>, ObjMember>>,
- value_cache: RefCell<HashMap<(Rc<str>, usize), Option<Val>>>,
+ value_cache: RefCell<HashMap<CacheKey, Option<Val>>>,
}
#[derive(Clone)]
pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);
crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -1,7 +1,8 @@
use crate::{
- create_error_result, evaluate,
+ error::Error::*,
+ evaluate,
function::{parse_function_call, parse_function_call_map, place_args},
- with_state, Context, Error, ObjValue, Result,
+ throw, with_state, Context, ObjValue, Result,
};
use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};
use std::{
@@ -157,14 +158,14 @@
if num.is_finite() {
Ok(Val::Num(num))
} else {
- create_error_result(Error::RuntimeError("overflow".into()))
+ throw!(RuntimeError("overflow".into()))
}
}
pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {
let this_type = self.value_type()?;
if this_type != val_type {
- create_error_result(Error::TypeMismatch(context, vec![val_type], this_type))
+ throw!(TypeMismatch(context, vec![val_type], this_type))
} else {
Ok(())
}
@@ -263,15 +264,15 @@
(Val::Null, Val::Null) => true,
(Val::Str(a), Val::Str(b)) => a == b,
(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,
- (Val::Arr(_), Val::Arr(_)) => create_error_result(Error::RuntimeError(
+ (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(
"primitiveEquals operates on primitive types, got array".into(),
- ))?,
- (Val::Obj(_), Val::Obj(_)) => create_error_result(Error::RuntimeError(
+ )),
+ (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(
"primitiveEquals operates on primitive types, got object".into(),
- ))?,
- (a, b) if is_function_like(&a) && is_function_like(&b) => create_error_result(
- Error::RuntimeError("cannot test equality of functions".into()),
- )?,
+ )),
+ (a, b) if is_function_like(&a) && is_function_like(&b) => {
+ throw!(RuntimeError("cannot test equality of functions".into()))
+ }
(_, _) => false,
})
}
@@ -376,7 +377,7 @@
buf.push('}');
}
Val::Func(_) | Val::Intristic(_, _) => {
- create_error_result(Error::RuntimeError("tried to manifest function".into()))?
+ throw!(RuntimeError("tried to manifest function".into()))
}
Val::Lazy(_) => unreachable!(),
};
crates/jrsonnet-parser/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -258,7 +258,7 @@
/// importStr "file.txt"
ImportStr(PathBuf),
/// error "I'm broken"
- Error(LocExpr),
+ ErrorStmt(LocExpr),
/// a(b, c)
Apply(LocExpr, ArgsDesc, bool),
/// a[b]
crates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -197,7 +197,7 @@
/ l(s,<keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}>)
/ l(s,<assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }>)
- / l(s,<keyword("error") _ expr:expr(s) { Expr::Error(expr) }>)
+ / l(s,<keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }>)
rule slice_part(s: &ParserSettings) -> Option<LocExpr>
= e:(_ e:expr(s) _{e})? {e}