difftreelog
refact: simplify error management
in: master
18 files changed
bindings/jsonnet/src/import.rsdiffbeforeafterboth1//! Import resolution manipulation utilities1//! Import resolution manipulation utilities223use jrsonnet_evaluator::{3use jrsonnet_evaluator::{4 create_error, create_error_result, Error, EvaluationState, ImportResolver, Result,4 error::{Error::*, Result},5 throw, EvaluationState, ImportResolver,5};6};6use std::{7use std::{7 any::Any,8 any::Any,55 let result_str = result_raw.to_str().unwrap();56 let result_str = result_raw.to_str().unwrap();56 assert!(success == 0 || success == 1);57 assert!(success == 0 || success == 1);57 if success == 0 {58 if success == 0 {59 unsafe { CString::from_raw(result_ptr) };58 let result = result_str.to_owned();60 let result = result_str.to_owned();59 let err = Err(create_error(Error::ImportCallbackError(result)));61 throw!(ImportCallbackError(result));60 unsafe { CString::from_raw(result_ptr) };61 return err;62 }62 }636364 let found_here_raw = unsafe { CStr::from_ptr(found_here) };64 let found_here_raw = unsafe { CStr::from_ptr(found_here) };121 return Ok(Rc::new(cloned));121 return Ok(Rc::new(cloned));122 }122 }123 }123 }124 create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))124 throw!(ImportFileNotFound(from.clone(), path.clone()))125 }125 }126 }126 }127 fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {127 fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {128 let mut file =128 let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;129 File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;130 let mut out = String::new();129 let mut out = String::new();131 file.read_to_string(&mut out)130 file.read_to_string(&mut out)132 .map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;131 .map_err(|_e| ImportBadFileUtf8(id.clone()))?;133 Ok(out.into())132 Ok(out.into())134 }133 }135 unsafe fn as_any(&self) -> &dyn Any {134 unsafe fn as_any(&self) -> &dyn Any {cmds/jrsonnet/src/main.rsdiffbeforeafterboth1use clap::Clap;1use clap::Clap;2use jrsonnet_cli::{ConfigureState, GeneralOpts, InputOpts, ManifestOpts};2use jrsonnet_cli::{ConfigureState, GeneralOpts, InputOpts, ManifestOpts};3use jrsonnet_evaluator::{EvaluationState, Result};3use jrsonnet_evaluator::{error::Result, EvaluationState};4use std::{path::PathBuf, rc::Rc};4use std::{path::PathBuf, rc::Rc};556#[global_allocator]6#[global_allocator]crates/jrsonnet-cli/src/ext.rsdiffbeforeafterboth1use crate::ConfigureState;1use crate::ConfigureState;2use clap::Clap;2use clap::Clap;3use jrsonnet_evaluator::{EvaluationState, Result};3use jrsonnet_evaluator::{error::Result, EvaluationState};4use std::str::FromStr;4use std::str::FromStr;556#[derive(Clone)]6#[derive(Clone)]crates/jrsonnet-cli/src/lib.rsdiffbeforeafterboth9pub use trace::*;9pub use trace::*;101011use clap::Clap;11use clap::Clap;12use jrsonnet_evaluator::{EvaluationState, FileImportResolver, Result};12use jrsonnet_evaluator::{error::Result, EvaluationState, FileImportResolver};13use std::path::PathBuf;13use std::path::PathBuf;141415pub trait ConfigureState {15pub trait ConfigureState {crates/jrsonnet-cli/src/manifest.rsdiffbeforeafterboth1use crate::ConfigureState;1use crate::ConfigureState;2use clap::Clap;2use clap::Clap;3use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Result};3use jrsonnet_evaluator::{error::Result, EvaluationState, ManifestFormat};4use std::str::FromStr;4use std::str::FromStr;556pub enum ManifestFormatName {6pub enum ManifestFormatName {crates/jrsonnet-cli/src/tla.rsdiffbeforeafterboth1use crate::{ConfigureState, ExtStr};1use crate::{ConfigureState, ExtStr};2use clap::Clap;2use clap::Clap;3use jrsonnet_evaluator::{EvaluationState, Result};3use jrsonnet_evaluator::{error::Result, EvaluationState};445#[derive(Clap)]5#[derive(Clap)]6// #[clap(help_heading = "TOP LEVEL ARGUMENTS")]6// #[clap(help_heading = "TOP LEVEL ARGUMENTS")]crates/jrsonnet-cli/src/trace.rsdiffbeforeafterboth1use crate::ConfigureState;1use crate::ConfigureState;2use clap::Clap;2use clap::Clap;3use jrsonnet_evaluator::{3use jrsonnet_evaluator::{4 error::Result,4 trace::{CompactFormat, ExplainingFormat, PathResolver},5 trace::{CompactFormat, ExplainingFormat, PathResolver},5 EvaluationState, Result,6 EvaluationState,6};7};7use std::str::FromStr;8use std::str::FromStr;89crates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth1//! faster std.format impl1//! faster std.format impl2#![allow(clippy::too_many_arguments)]2#![allow(clippy::too_many_arguments)]334use crate::{4use crate::{error::Error::*, throw, to_string, LocError, ObjValue, Result, Val, ValType};5 create_error, create_error_result, to_string, Error, LocError, ObjValue, Val, ValType,6};758#[derive(Debug)]6#[derive(Debug, Clone)]9pub enum FormatError {7pub enum FormatError {10 TruncatedFormatCode,8 TruncatedFormatCode,11 UnrecognizedConversionType(char),9 UnrecognizedConversionType(char),12 ValueError(LocError),131014 NotEnoughValues,11 NotEnoughValues,151216 CannotUseStarWidthWithObject,13 CannotUseStarWidthWithObject,17 MappingKeysRequired,14 MappingKeysRequired,18 NoSuchField(Rc<str>),15 NoSuchFormatField(Rc<str>),19}16}1720impl From<LocError> for FormatError {18impl From<FormatError> for LocError {21 fn from(e: LocError) -> Self {19 fn from(e: FormatError) -> Self {22 Self::ValueError(e)20 Self::new(Format(e))23 }21 }24}22}2325use std::rc::Rc;24use std::rc::Rc;26use FormatError::*;25use FormatError::*;2627type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;272828pub fn try_parse_mapping_key(str: &str) -> Result<(&str, &str), FormatError> {29pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {29 if str.is_empty() {30 if str.is_empty() {30 return Err(TruncatedFormatCode);31 return Err(TruncatedFormatCode);31 }32 }84 pub sign: bool,85 pub sign: bool,85}86}868787pub fn try_parse_cflags(str: &str) -> Result<(CFlags, &str), FormatError> {88pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {88 if str.is_empty() {89 if str.is_empty() {89 return Err(TruncatedFormatCode);90 return Err(TruncatedFormatCode);90 }91 }113 Star,114 Star,114 Fixed(usize),115 Fixed(usize),115}116}116pub fn try_parse_field_width(str: &str) -> Result<(Width, &str), FormatError> {117pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {117 if str.is_empty() {118 if str.is_empty() {118 return Err(TruncatedFormatCode);119 return Err(TruncatedFormatCode);119 }120 }134 Ok((Width::Fixed(out), &str[digits..]))135 Ok((Width::Fixed(out), &str[digits..]))135}136}136137137pub fn try_parse_precision(str: &str) -> Result<(Option<Width>, &str), FormatError> {138pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {138 if str.is_empty() {139 if str.is_empty() {139 return Err(TruncatedFormatCode);140 return Err(TruncatedFormatCode);140 }141 }147}148}148149149// Only skips150// Only skips150pub fn try_parse_length_modifier(str: &str) -> Result<&str, FormatError> {151pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {151 if str.is_empty() {152 if str.is_empty() {152 return Err(TruncatedFormatCode);153 return Err(TruncatedFormatCode);153 }154 }159 return Err(TruncatedFormatCode);160 return Err(TruncatedFormatCode);160 }161 }161 }162 }162 Ok(&str[idx..])163 Ok(((), &str[idx..]))163}164}164165165#[derive(Debug)]166#[derive(Debug, PartialEq)]166pub enum ConvTypeV {167pub enum ConvTypeV {167 Decimal,168 Decimal,168 Octal,169 Octal,179 caps: bool,180 caps: bool,180}181}181182182pub fn parse_conversion_type(str: &str) -> Result<(ConvType, &str), FormatError> {183pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {183 if str.is_empty() {184 if str.is_empty() {184 return Err(TruncatedFormatCode);185 return Err(TruncatedFormatCode);185 }186 }214 convtype: ConvTypeV,215 convtype: ConvTypeV,215 caps: bool,216 caps: bool,216}217}217pub fn parse_code(str: &str) -> Result<(Code, &str), FormatError> {218pub fn parse_code(str: &str) -> ParseResult<Code> {218 if str.is_empty() {219 if str.is_empty() {219 return Err(TruncatedFormatCode);220 return Err(TruncatedFormatCode);220 }221 }221 let (mkey, str) = try_parse_mapping_key(str)?;222 let (mkey, str) = try_parse_mapping_key(str)?;222 let (cflags, str) = try_parse_cflags(str)?;223 let (cflags, str) = try_parse_cflags(str)?;223 let (width, str) = try_parse_field_width(str)?;224 let (width, str) = try_parse_field_width(str)?;224 let (precision, str) = try_parse_precision(str)?;225 let (precision, str) = try_parse_precision(str)?;225 let str = try_parse_length_modifier(str)?;226 let (_, str) = try_parse_length_modifier(str)?;226 let (convtype, str) = parse_conversion_type(str)?;227 let (convtype, str) = parse_conversion_type(str)?;227228228 Ok((229 Ok((243 String(&'s str),244 String(&'s str),244 Code(Code<'s>),245 Code(Code<'s>),245}246}246pub fn parse_codes(mut str: &str) -> Result<Vec<Element>, FormatError> {247pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {247 let mut bytes = str.as_bytes();248 let mut bytes = str.as_bytes();248 let mut out = vec![];249 let mut out = vec![];249 let mut offset = 0;250 let mut offset = 0;453 code: &Code,454 code: &Code,454 width: usize,455 width: usize,455 precision: Option<usize>,456 precision: Option<usize>,456) -> Result<(), FormatError> {457) -> Result<()> {457 let clfags = &code.cflags;458 let clfags = &code.cflags;458 let (fpprec, iprec) = match precision {459 let (fpprec, iprec) = match precision {459 Some(v) => (v, v),460 Some(v) => (v, v),565 ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {566 ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {566 Val::Num(n) => tmp_out.push(567 Val::Num(n) => tmp_out.push(567 std::char::from_u32(n as u32)568 std::char::from_u32(n as u32)568 .ok_or_else(|| create_error(Error::InvalidUnicodeCodepointGot(n as u32)))?,569 .ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,569 ),570 ),570 Val::Str(s) => {571 Val::Str(s) => {571 if s.chars().count() != 1 {572 if s.chars().count() != 1 {572 create_error_result(Error::RuntimeError(573 throw!(RuntimeError(573 format!("%c expected 1 char string, got {}", s.chars().count()).into(),574 format!("%c expected 1 char string, got {}", s.chars().count()).into(),574 ))?;575 ));575 }576 }576 tmp_out.push_str(&s);577 tmp_out.push_str(&s);577 }578 }578 _ => {579 _ => {579 create_error_result(Error::TypeMismatch(580 throw!(TypeMismatch(580 "%c requires number/string",581 "%c requires number/string",581 vec![ValType::Num, ValType::Str],582 vec![ValType::Num, ValType::Str],582 value.value_type()?,583 value.value_type()?,583 ))?;584 ));584 }585 }585 },586 },586 ConvTypeV::Percent => tmp_out.push('%'),587 ConvTypeV::Percent => tmp_out.push('%'),603 Ok(())604 Ok(())604}605}605606606pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String, FormatError> {607pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {607 let codes = parse_codes(&str)?;608 let codes = parse_codes(&str)?;608 let mut out = String::new();609 let mut out = String::new();609610616 let width = match c.width {617 let width = match c.width {617 Width::Star => {618 Width::Star => {618 if values.is_empty() {619 if values.is_empty() {619 return Err(FormatError::NotEnoughValues);620 throw!(NotEnoughValues);620 }621 }621 let value = &values[0];622 let value = &values[0];622 values = &values[1..];623 values = &values[1..];627 let precision = match c.precision {628 let precision = match c.precision {628 Some(Width::Star) => {629 Some(Width::Star) => {629 if values.is_empty() {630 if values.is_empty() {630 return Err(FormatError::NotEnoughValues);631 throw!(NotEnoughValues);631 }632 }632 let value = &values[0];633 let value = &values[0];633 values = &values[1..];634 values = &values[1..];642 &Val::Null643 &Val::Null643 } else {644 } else {644 if values.is_empty() {645 if values.is_empty() {645 return Err(FormatError::NotEnoughValues);646 throw!(NotEnoughValues);646 }647 }647 let value = &values[0];648 let value = &values[0];648 values = &values[1..];649 values = &values[1..];657 Ok(out)658 Ok(out)658}659}659660660pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {661pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {661 let codes = parse_codes(&str)?;662 let codes = parse_codes(&str)?;662 let mut out = String::new();663 let mut out = String::new();663664670 // TODO: Operate on ref671 // TODO: Operate on ref671 let f: Rc<str> = c.mkey.into();672 let f: Rc<str> = c.mkey.into();672 if f.is_empty() {673 if f.is_empty() {673 return Err(FormatError::MappingKeysRequired);674 throw!(MappingKeysRequired);674 }675 }675 let width = match c.width {676 let width = match c.width {676 Width::Star => {677 Width::Star => {677 return Err(FormatError::CannotUseStarWidthWithObject);678 throw!(CannotUseStarWidthWithObject);678 }679 }679 Width::Fixed(n) => n,680 Width::Fixed(n) => n,680 };681 };681 let precision = match c.precision {682 let precision = match c.precision {682 Some(Width::Star) => {683 Some(Width::Star) => {683 return Err(FormatError::CannotUseStarWidthWithObject);684 throw!(CannotUseStarWidthWithObject);684 }685 }685 Some(Width::Fixed(n)) => Some(n),686 Some(Width::Fixed(n)) => Some(n),686 None => None,687 None => None,687 };688 };688 let value = if let Some(v) = values.get(f.clone())? {689 let value = if let Some(v) = values.get(f.clone())? {689 v690 v690 } else {691 } else {691 return Err(FormatError::NoSuchField(f));692 throw!(NoSuchFormatField(f));692 };693 };693694694 format_code(&mut out, &value, &c, width, precision)?;695 format_code(&mut out, &value, &c, width, precision)?;crates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth1use crate::{1use crate::{2 create_error, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val, Error,2 error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,3 LazyBinding, LazyVal, ObjValue, Result, Val,3 LazyBinding, LazyVal, ObjValue, Result, Val,4};4};5use std::{5use std::{61 }61 }626263 pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {63 pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {64 self.064 Ok(self65 .065 .bindings66 .bindings66 .get(&name)67 .get(&name)67 .cloned()68 .cloned()68 .ok_or_else(|| create_error(Error::UnknownVariable(name)))69 .ok_or_else(|| UnknownVariable(name))?)69 }70 }70 pub fn into_future(self, ctx: FutureContext) -> Context {71 pub fn into_future(self, ctx: FutureContext) -> Context {71 {72 {crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth1use crate::{Val, ValType};1use crate::{builtin::format::FormatError, Val, ValType};2use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};2use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};3use std::{path::PathBuf, rc::Rc};3use std::{path::PathBuf, rc::Rc};4462 ImportCallbackError(String),62 ImportCallbackError(String),63 InvalidUnicodeCodepointGot(u32),63 InvalidUnicodeCodepointGot(u32),6465 Format(FormatError),64}66}67impl From<Error> for LocError {68 fn from(e: Error) -> Self {69 Self(e, StackTrace(vec![]))70 }71}657266#[derive(Clone, Debug)]73#[derive(Clone, Debug)]67pub struct StackTraceElement {74pub struct StackTraceElement {738074#[derive(Debug, Clone)]81#[derive(Debug, Clone)]75pub struct LocError(pub Error, pub StackTrace);82pub struct LocError(pub Error, pub StackTrace);83impl LocError {84 pub fn new(e: Error) -> Self {85 Self(e, StackTrace(vec![]))86 }87}8876pub type Result<V> = std::result::Result<V, LocError>;89pub type Result<V> = std::result::Result<V, LocError>;9091#[macro_export]92macro_rules! throw {93 ($e: expr) => {94 return Err($e.into());95 };96}7797crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth1use crate::{1use crate::{2 builtin::format::{format_arr, format_obj},2 builtin::format::{format_arr, format_obj},3 context_creator, create_error, create_error_result, equals, escape_string_json, future_wrapper,3 context_creator, equals,4 error::Error::*,4 lazy_val, manifest_json_ex, parse_args, primitive_equals, push, with_state, Context,5 escape_string_json, future_wrapper, lazy_val, manifest_json_ex, parse_args, primitive_equals,5 ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,6 push, throw, with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError,6 ValType,7 ObjMember, ObjValue, Result, Val, ValType,7};8};8use closure::closure;9use closure::closure;9use jrsonnet_parser::{10use jrsonnet_parser::{10 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,11 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,11 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,12 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,12 Visibility,13 Visibility,13};14};14use std::{cmp::Ordering, collections::HashMap, rc::Rc};15use std::{cmp::Ordering, collections::HashMap, path::PathBuf, rc::Rc};151616pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {17pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {17 let b = b.clone();18 let b = b.clone();79 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),80 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),80 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),81 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),81 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),82 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),82 (op, o) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(83 (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),83 op,84 o.value_type()?,85 ))?,86 })84 })87}85}8886100 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),98 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),101 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),99 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),102 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,100 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,103 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(101 _ => throw!(BinaryOperatorDoesNotOperateOnValues(104 BinaryOpType::Add,102 BinaryOpType::Add,105 a.value_type()?,103 a.value_type()?,106 b.value_type()?,104 b.value_type()?,107 ))?,105 )),108 })106 })109}107}110108145 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,143 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,146 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {144 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {147 if *v2 <= f64::EPSILON {145 if *v2 <= f64::EPSILON {148 create_error_result(crate::Error::DivisionByZero)?146 throw!(DivisionByZero)149 }147 }150 Val::new_checked_num(v1 / v2)?148 Val::new_checked_num(v1 / v2)?151 }149 }168 }166 }169 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {167 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {170 if *v2 < 0.0 {168 if *v2 < 0.0 {171 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?169 throw!(RuntimeError("shift by negative exponent".into()))172 }170 }173 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)171 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)174 }172 }175 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {173 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {176 if *v2 < 0.0 {174 if *v2 < 0.0 {177 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?175 throw!(RuntimeError("shift by negative exponent".into()))178 }176 }179 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)177 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)180 }178 }181179182 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(180 _ => throw!(BinaryOperatorDoesNotOperateOnValues(183 op,181 op,184 a.value_type()?,182 a.value_type()?,185 b.value_type()?,183 b.value_type()?,186 ))?,184 )),187 })185 })188}186}189187218 }216 }219 Some(out.into_iter().flatten().flatten().collect())217 Some(out.into_iter().flatten().flatten().collect())220 }218 }221 _ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,219 _ => throw!(InComprehensionCanOnlyIterateOverArray),222 }220 }223 }221 }224 })222 })379 },377 },380 );378 );381 }379 }382 v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,380 v => throw!(FieldMustBeStringGot(v.value_type()?)),383 }381 }384 }382 }385383409 Ok(match value {407 Ok(match value {410 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {408 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {411 // arr/string/function409 // arr/string/function412 ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [410 ("std", "length") => parse_args!(context, "std.length", args, 1, [413 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];411 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];414 ], {412 ], {415 Ok(match x {413 Ok(match x {423 ),421 ),424 _ => unreachable!(),422 _ => unreachable!(),425 })423 })426 }))?,424 })?,427 // any425 // any428 ("std", "type") => parse_args!(context, "std.type", args, 1, [426 ("std", "type") => parse_args!(context, "std.type", args, 1, [429 0, x, vec![];427 0, x, vec![];430 ], {428 ], {431 Val::Str(x.value_type()?.name().into())429 Ok(Val::Str(x.value_type()?.name().into()))432 }),430 })?,433 // length, idx=>any431 // length, idx=>any434 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [432 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [435 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];433 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];436 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];434 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];437 ], {435 ], {438 if sz < 0.0 {436 if sz < 0.0 {439 create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;437 throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));440 }438 }441 let mut out = Vec::with_capacity(sz as usize);439 let mut out = Vec::with_capacity(sz as usize);442 for i in 0..sz as usize {440 for i in 0..sz as usize {455 str.chars().count() == 1,453 str.chars().count() == 1,456 "std.codepoint should receive single char string"454 "std.codepoint should receive single char string"457 );455 );458 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)456 Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))459 }),457 })?,460 // object, includeHidden458 // object, includeHidden461 ("std", "objectFieldsEx") => {459 ("std", "objectFieldsEx") => {462 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [460 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [478 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];476 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];479 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];477 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];480 ], {478 ], {481 Val::Bool(479 Ok(Val::Bool(482 obj.fields_visibility()480 obj.fields_visibility()483 .into_iter()481 .into_iter()484 .filter(|(_k, v)| *v || inc_hidden)482 .filter(|(_k, v)| *v || inc_hidden)485 .any(|(k, _v)| *k == *f),483 .any(|(k, _v)| *k == *f),486 )484 ))487 }),485 })?,488 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [486 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [489 0, a, vec![];487 0, a, vec![];490 1, b, vec![];488 1, b, vec![];491 ], {489 ], {492 Val::Bool(primitive_equals(&a, &b)?)490 Ok(Val::Bool(primitive_equals(&a, &b)?))493 }),491 })?,494 // faster492 // faster495 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [493 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [496 0, a, vec![];494 0, a, vec![];497 1, b, vec![];495 1, b, vec![];498 ], {496 ], {499 Val::Bool(equals(&a, &b)?)497 Ok(Val::Bool(equals(&a, &b)?))500 }),498 })?,501 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [499 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [502 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];500 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];503 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];501 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];504 ], {502 ], {505 Val::Num(a % b)503 Ok(Val::Num(a % b))506 }),504 })?,507 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [505 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [508 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];506 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];509 ], {507 ], {510 Val::Num(x.floor())508 Ok(Val::Num(x.floor()))511 }),509 })?,512 ("std", "log") => parse_args!(context, "std.log", args, 2, [510 ("std", "log") => parse_args!(context, "std.log", args, 2, [513 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];511 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];514 ], {512 ], {515 Val::Num(n.ln())513 Ok(Val::Num(n.ln()))516 }),514 })?,517 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [515 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [518 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];516 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];519 1, rest, vec![];517 1, rest, vec![];526 });524 });527 }525 }528 eprintln!(" {}", str);526 eprintln!(" {}", str);529 rest527 Ok(rest)530 }),528 })?,531 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [529 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [532 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];530 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];533 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];531 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];534 ], {532 ], {535 Val::Num(x.powf(n))533 Ok(Val::Num(x.powf(n)))536 }),534 })?,537 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [535 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [538 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];536 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];539 ], {537 ], {540 with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(538 Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(541 || create_error(crate::Error::UndefinedExternalVariable(x)),539 || UndefinedExternalVariable(x),542 )?540 )?)543 }),541 })?,544 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [542 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [545 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];543 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];546 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];544 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];583 Ok(acc)581 Ok(acc)584 }))?,582 }))?,585 // faster583 // faster584 #[allow(non_snake_case)]586 ("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [585 ("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [587 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];586 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];588 1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];587 1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];598 match keyF.evaluate_values(context.clone(), &[k.clone()]) {597 match keyF.evaluate_values(context.clone(), &[k.clone()]) {599 Ok(Val::Str(v)) => v,598 Ok(Val::Str(v)) => v,600 Ok(_) => {599 Ok(_) => {601 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));600 err = Some(LocError::new(RuntimeError("types of all array elements should equal".into())));602 "".into()601 "".into()603 }602 }604 Err(e) => {603 Err(e) => {617 match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {616 match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {618 (Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),617 (Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),619 (Ok(_a), Ok(_b)) => {618 (Ok(_a), Ok(_b)) => {620 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));619 err = Some(RuntimeError("types of all array elements should equal".into()).into());621 Ordering::Equal620 Ordering::Equal622 }621 }623 (Err(e), _) | (_, Err(e)) => {622 (Err(e), _) | (_, Err(e)) => {630 return Err(e);629 return Err(e);631 }630 }632 },631 },633 _ => return Err(create_error(crate::error::Error::RuntimeError("keys should be number or string".into())))632 _ => throw!(RuntimeError("keys should be number or string".into()))634 }633 }635 Ok(Val::Arr(Rc::new(new_arr)))634 Ok(Val::Arr(Rc::new(new_arr)))636 }))?,635 }))?,637 // faster636 // faster638 ("std", "format") => parse_args!(context, "std.format", args, 2, [637 ("std", "format") => parse_args!(context, "std.format", args, 2, [639 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];638 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];640 1, vals: [Val::Arr|Val::Obj], vec![ValType::Arr, ValType::Obj];639 1, vals, vec![]641 ], {640 ], {641 push(&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)), ||format!("std.format of {}", str), ||{642 match vals {642 Ok(match vals {643 Val::Arr(vals) => Val::Str(format_arr(&str, &vals).unwrap().into()),643 Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),644 Val::Obj(obj) => Val::Str(format_obj(&str, &obj).unwrap().into()),644 Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),645 _ => unreachable!()645 o => Val::Str(format_arr(&str, &[o])?.into()),646 }646 })647 })647 }),648 })?,648 // faster649 // faster649 ("std", "range") => parse_args!(context, "std.range", args, 2, [650 ("std", "range") => parse_args!(context, "std.range", args, 2, [650 0, from: [Val::Num]!!Val::Num, vec![ValType::Num];651 0, from: [Val::Num]!!Val::Num, vec![ValType::Num];654 for i in from as usize..=to as usize {655 for i in from as usize..=to as usize {655 out.push(Val::Num(i as f64));656 out.push(Val::Num(i as f64));656 }657 }657 Val::Arr(Rc::new(out))658 Ok(Val::Arr(Rc::new(out)))658 }),659 })?,659 ("std", "char") => parse_args!(context, "std.char", args, 1, [660 ("std", "char") => parse_args!(context, "std.char", args, 1, [660 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];661 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];661 ], {662 ], {662 let mut out = String::new();663 let mut out = String::new();663 out.push(std::char::from_u32(n as u32).ok_or_else(||664 out.push(std::char::from_u32(n as u32).ok_or_else(||664 create_error(crate::error::Error::InvalidUnicodeCodepointGot(n as u32))665 InvalidUnicodeCodepointGot(n as u32)665 )?);666 )?);666 Ok(Val::Str(out.into()))667 Ok(Val::Str(out.into()))667 })?,668 })?,668 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [669 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [669 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];670 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];670 ], {671 ], {671 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))672 Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))672 }),673 })?,673 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [674 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [674 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];675 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];675 ], {676 ], {679 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [680 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [680 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];681 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];681 ], {682 ], {682 Val::Str(match input {683 Ok(Val::Str(match input {683 Val::Str(s) => {684 Val::Str(s) => {684 base64::encode(s.bytes().collect::<Vec<_>>()).into()685 base64::encode(s.bytes().collect::<Vec<_>>()).into()685 },686 },689 }).collect::<Result<Vec<_>>>()?).into()690 }).collect::<Result<Vec<_>>>()?).into()690 },691 },691 _ => unreachable!()692 _ => unreachable!()692 })693 }))693 }),694 })?,694 // faster695 // faster695 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [696 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [696 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];697 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];711 out.reserve(items.len());712 out.reserve(items.len());712 out.extend(items.iter().cloned());713 out.extend(items.iter().cloned());713 } else {714 } else {714 create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;715 throw!(RuntimeError("in std.join all items should be arrays".into()));715 }716 }716 }717 }717718729 first = false;730 first = false;730 out += &item;731 out += &item;731 } else {732 } else {732 create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;733 throw!(RuntimeError("in std.join all items should be strings".into()));733 }734 }734 }735 }735736742 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [743 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [743 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];744 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];744 ], {745 ], {745 Val::Str(escape_string_json(&str_).into())746 Ok(Val::Str(escape_string_json(&str_).into()))746 }),747 })?,747 // Faster748 // Faster748 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [749 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [749 0, value, vec![];750 0, value, vec![];750 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];751 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];751 ], {752 ], {752 Val::Str(manifest_json_ex(&value, &indent)?.into())753 Ok(Val::Str(manifest_json_ex(&value, &indent)?.into()))753 }),754 })?,754 (ns, name) => {755 (ns, name) => throw!(IntristicNotFound(ns.into(), name.into())),755 create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?756 }757 },756 },758 Val::Func(f) => {757 Val::Func(f) => {759 let body = || f.evaluate(context, args, tailstrict);758 let body = || f.evaluate(context, args, tailstrict);763 push(loc, || format!("function <{}> call", f.name), body)?762 push(loc, || format!("function <{}> call", f.name), body)?764 }763 }765 }764 }766 v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,765 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),767 })766 })768}767}769768784 context783 context785 .this()784 .this()786 .clone()785 .clone()787 .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,786 .ok_or_else(|| CantUseSelfOutsideOfObject)?,788 ),787 ),789 Literal(LiteralType::Dollar) => Val::Obj(788 Literal(LiteralType::Dollar) => Val::Obj(790 context789 context791 .dollar()790 .dollar()792 .clone()791 .clone()793 .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,792 .ok_or_else(|| NoTopLevelObjectFound)?,794 ),793 ),795 Literal(LiteralType::True) => Val::Bool(true),794 Literal(LiteralType::True) => Val::Bool(true),796 Literal(LiteralType::False) => Val::Bool(false),795 Literal(LiteralType::False) => Val::Bool(false),825 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {824 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {826 Val::Intristic(n, s)825 Val::Intristic(n, s)827 } else {826 } else {828 create_error_result(crate::Error::NoSuchField(s))?827 throw!(NoSuchField(s))829 }828 }830 }829 }831 (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(830 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(832 ValType::Obj,831 ValType::Obj,833 ValType::Str,832 ValType::Str,834 n.value_type()?,833 n.value_type()?,835 ))?,834 )),836835837 (Val::Arr(v), Val::Num(n)) => {836 (Val::Arr(v), Val::Num(n)) => {838 if n.fract() > f64::EPSILON {837 if n.fract() > f64::EPSILON {839 create_error_result(crate::Error::FractionalIndex)?838 throw!(FractionalIndex)840 }839 }841 v.get(n as usize)840 v.get(n as usize)842 .ok_or_else(|| {841 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?843 create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))844 })?845 .clone()842 .clone()846 .unwrap_if_lazy()?843 .unwrap_if_lazy()?847 }844 }848 (Val::Arr(_), Val::Str(n)) => {845 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),849 create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?850 }851 (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(846 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(852 ValType::Arr,847 ValType::Arr,853 ValType::Num,848 ValType::Num,854 n.value_type()?,849 n.value_type()?,855 ))?,850 )),856851857 (Val::Str(s), Val::Num(n)) => Val::Str(852 (Val::Str(s), Val::Num(n)) => Val::Str(858 s.chars()853 s.chars()861 .collect::<String>()856 .collect::<String>()862 .into(),857 .into(),863 ),858 ),864 (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(859 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(865 ValType::Str,860 ValType::Str,866 ValType::Num,861 ValType::Num,867 n.value_type()?,862 n.value_type()?,868 ))?,863 )),869864870 (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,865 (v, _) => throw!(CantIndexInto(v.value_type()?)),871 }866 }872 }867 }873 LocalExpr(bindings, returned) => {868 LocalExpr(bindings, returned) => {926 if assertion_result {921 if assertion_result {927 evaluate(context, returned)?922 evaluate(context, returned)?928 } else if let Some(msg) = msg {923 } else if let Some(msg) = msg {929 create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?924 throw!(AssertionFailed(evaluate(context, msg)?));930 } else {925 } else {931 create_error_result(crate::Error::AssertionFailed(Val::Null))?926 throw!(AssertionFailed(Val::Null));932 }927 }933 }928 }934 Error(e) => push(929 ErrorStmt(e) => push(935 &loc,930 &loc,936 || "error statement".to_owned(),931 || "error statement".to_owned(),937 || {932 || {938 create_error_result(crate::Error::RuntimeError(933 throw!(RuntimeError(939 evaluate(context, e)?.try_cast_str("error text should be string")?,934 evaluate(context, e)?.try_cast_str("error text should be string")?,940 ))?935 ))941 },936 },942 )?,937 )?,943 IfElse {938 IfElse {978 import_location.pop();973 import_location.pop();979 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)974 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)980 }975 }981 Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),976 Literal(LiteralType::Super) => throw!(StandaloneSuper),982 })977 })983}978}984979crates/jrsonnet-evaluator/src/function.rsdiffbeforeafterboth1use crate::{1use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};2 create_error, create_error_result, evaluate, lazy_val, resolved_lazy_val, Context, Error,3 Result, Val,4};5use closure::closure;2use closure::closure;6use jrsonnet_parser::{ArgsDesc, ParamsDesc};3use jrsonnet_parser::{ArgsDesc, ParamsDesc};30 params27 params31 .iter()28 .iter()32 .position(|p| *p.0 == *name)29 .position(|p| *p.0 == *name)33 .ok_or_else(|| create_error(Error::UnknownFunctionParameter(name.clone())))?30 .ok_or_else(|| UnknownFunctionParameter(name.clone()))?34 } else {31 } else {35 id32 id36 };33 };373438 if idx >= params.len() {35 if idx >= params.len() {39 create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;36 throw!(TooManyArgsFunctionHas(params.len()));40 }37 }41 if positioned_args[idx].is_some() {38 if positioned_args[idx].is_some() {42 create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;39 throw!(BindingParameterASecondTime(params[idx].0.clone()));43 }40 }44 positioned_args[idx] = Some(arg.1.clone());41 positioned_args[idx] = Some(arg.1.clone());45 }42 }50 } else if let Some(default) = &p.1 {47 } else if let Some(default) = &p.1 {51 (body_ctx.clone().expect(NO_DEFAULT_CONTEXT), default)48 (body_ctx.clone().expect(NO_DEFAULT_CONTEXT), default)52 } else {49 } else {53 create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;50 throw!(FunctionParameterNotBoundInCall(p.0.clone()));54 unreachable!()55 };51 };56 let val = if tailstrict {52 let val = if tailstrict {57 resolved_lazy_val!(evaluate(ctx, expr)?)53 resolved_lazy_val!(evaluate(ctx, expr)?)74 let mut out = HashMap::new();70 let mut out = HashMap::new();75 let mut positioned_args = vec![None; params.0.len()];71 let mut positioned_args = vec![None; params.0.len()];76 for (name, val) in args.iter() {72 for (name, val) in args.iter() {77 let idx = params.iter().position(|p| *p.0 == **name).ok_or_else(|| {73 let idx = params74 .iter()75 .position(|p| *p.0 == **name)78 create_error(Error::UnknownFunctionParameter((&name as &str).to_owned()))76 .ok_or_else(|| UnknownFunctionParameter((&name as &str).to_owned()))?;79 })?;807781 if idx >= params.len() {78 if idx >= params.len() {82 create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;79 throw!(TooManyArgsFunctionHas(params.len()));83 }80 }84 if positioned_args[idx].is_some() {81 if positioned_args[idx].is_some() {85 create_error_result(Error::BindingParameterASecondTime(params[idx].0.clone()))?;82 throw!(BindingParameterASecondTime(params[idx].0.clone()));86 }83 }87 positioned_args[idx] = Some(val.clone());84 positioned_args[idx] = Some(val.clone());88 }85 }104 })101 })105 }102 }106 } else {103 } else {107 create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;104 throw!(FunctionParameterNotBoundInCall(p.0.clone()));108 unreachable!()109 };105 };110 out.insert(p.0.clone(), val);106 out.insert(p.0.clone(), val);111 }107 }123 let mut positioned_args = vec![None; params.0.len()];119 let mut positioned_args = vec![None; params.0.len()];124 for (id, arg) in args.iter().enumerate() {120 for (id, arg) in args.iter().enumerate() {125 if id >= params.len() {121 if id >= params.len() {126 create_error_result(Error::TooManyArgsFunctionHas(params.len()))?;122 throw!(TooManyArgsFunctionHas(params.len()));127 }123 }128 positioned_args[id] = Some(arg);124 positioned_args[id] = Some(arg);129 }125 }134 } else if let Some(default) = &p.1 {130 } else if let Some(default) = &p.1 {135 evaluate(ctx.clone(), default)?131 evaluate(ctx.clone(), default)?136 } else {132 } else {137 create_error_result(Error::FunctionParameterNotBoundInCall(p.0.clone()))?;133 throw!(FunctionParameterNotBoundInCall(p.0.clone()));138 unreachable!()139 };134 };140 out.insert(p.0.clone(), resolved_lazy_val!(val));135 out.insert(p.0.clone(), resolved_lazy_val!(val));141 }136 }148 ($ctx: expr, $fn_name: expr, $args: expr, $total_args: expr, [143 ($ctx: expr, $fn_name: expr, $args: expr, $total_args: expr, [149 $($id: expr, $name: ident $(: [$($p: path)|+] $(!! $a: path)?)?, $nt: expr);+ $(;)?144 $($id: expr, $name: ident $(: [$($p: path)|+] $(!! $a: path)?)?, $nt: expr);+ $(;)?150 ], $handler:block) => {{145 ], $handler:block) => {{151 use crate::Error;146 use crate::{throw, error::Error::*};152 let args = $args;147 let args = $args;153 if args.len() > $total_args {148 if args.len() > $total_args {154 create_error_result(Error::TooManyArgsFunctionHas($total_args))?;149 throw!(TooManyArgsFunctionHas($total_args));155 }150 }156 $(151 $(157 if args.len() <= $id {152 if args.len() <= $id {158 create_error_result(Error::FunctionParameterNotBoundInCall(stringify!($name).into()))?;153 throw!(FunctionParameterNotBoundInCall(stringify!($name).into()));159 }154 }160 let $name = &args[$id];155 let $name = &args[$id];161 if $name.0.is_some() {156 if $name.0.is_some() {162 if $name.0.as_ref().unwrap() != stringify!($name) {157 if $name.0.as_ref().unwrap() != stringify!($name) {163 create_error_result(Error::IntristicArgumentReorderingIsNotSupportedYet)?;158 throw!(IntristicArgumentReorderingIsNotSupportedYet);164 }159 }165 }160 }166 let $name = evaluate($ctx.clone(), &$name.1)?;161 let $name = evaluate($ctx.clone(), &$name.1)?;167 $(162 $(168 match $name {163 match $name {169 $($p(_))|+ => {},164 $($p(_))|+ => {},170 _ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,165 _ => throw!(TypeMismatch(166 concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"),167 $nt, $name.value_type()?168 )),171 };169 };172 $(170 $(173 let $name = match $name {171 let $name = match $name {174 $a(v) => v,172 $a(v) => v,175 _ => create_error_result(Error::TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?))?,173 _ =>throw!(TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?)),176 };174 };177 )*175 )*178 )*176 )*179 )+177 )+180 $handler178 ($handler as crate::Result<_>)181 }};179 }};182}180}183181198 ], {196 ], {199 assert!((a - 2.0).abs() <= f64::EPSILON);197 assert!((a - 2.0).abs() <= f64::EPSILON);200 assert!((b - 1.0).abs() <= f64::EPSILON);198 assert!((b - 1.0).abs() <= f64::EPSILON);199 Ok(())201 });200 })201 .unwrap();202 Ok(())202 Ok(())203 })203 })204}204}crates/jrsonnet-evaluator/src/import.rsdiffbeforeafterboth1use crate::create_error_result;2use crate::{1use crate::{3 create_error,4 error::{Error, Result},2 error::{Error::*, Result},3 throw,5};4};6use fs::File;5use fs::File;7use std::fs;6use std::fs;28pub struct DummyImportResolver;27pub struct DummyImportResolver;29impl ImportResolver for DummyImportResolver {28impl ImportResolver for DummyImportResolver {30 fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {29 fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {31 create_error_result(Error::ImportNotSupported(from.clone(), path.clone()))30 throw!(ImportNotSupported(from.clone(), path.clone()))32 }31 }33 fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {32 fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {34 // Can be only caused by library direct consumer, not by supplied jsonnet33 // Can be only caused by library direct consumer, not by supplied jsonnet65 return Ok(Rc::new(cloned));64 return Ok(Rc::new(cloned));66 }65 }67 }66 }68 create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))67 throw!(ImportFileNotFound(from.clone(), path.clone()))69 }68 }70 }69 }71 fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {70 fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {72 let mut file =71 let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;73 File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;74 let mut out = String::new();72 let mut out = String::new();75 file.read_to_string(&mut out)73 file.read_to_string(&mut out)76 .map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;74 .map_err(|_e| ImportBadFileUtf8(id.clone()))?;77 Ok(out.into())75 Ok(out.into())78 }76 }79 unsafe fn as_any(&self) -> &dyn Any {77 unsafe fn as_any(&self) -> &dyn Any {crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth10mod builtin;10mod builtin;11mod ctx;11mod ctx;12mod dynamic;12mod dynamic;13mod error;13pub mod error;14mod evaluate;14mod evaluate;15mod function;15mod function;16mod import;16mod import;212122pub use ctx::*;22pub use ctx::*;23pub use dynamic::*;23pub use dynamic::*;24pub use error::*;24use error::{Error::*, LocError, Result, StackTraceElement};25pub use evaluate::*;25pub use evaluate::*;26pub use function::parse_function_call;26pub use function::parse_function_call;27pub use import::*;27pub use import::*;132pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {132pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {133 EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))133 EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))134}134}135pub fn create_error(err: Error) -> LocError {136 LocError(err, StackTrace(vec![]))137}138pub fn create_error_result<T>(err: Error) -> Result<T> {139 Err(LocError(err, StackTrace(vec![])))140}141pub(crate) fn push<T>(135pub(crate) fn push<T>(142 e: &Option<ExprLocation>,136 e: &Option<ExprLocation>,143 frame_desc: impl FnOnce() -> String,137 frame_desc: impl FnOnce() -> String,167 loc_data: true,161 loc_data: true,168 },162 },169 )163 )170 .map_err(|error| {164 .map_err(|error| ImportSyntaxError {171 create_error(Error::ImportSyntaxError {172 error,165 error,173 path,166 path,174 source_code,167 source_code,175 })168 })?,176 })?,177 )?;169 )?;178170179 Ok(())171 Ok(())292 if *stack_depth > self.max_stack() {284 if *stack_depth > self.max_stack() {293 // Error creation uses data, so i drop guard here285 // Error creation uses data, so i drop guard here294 drop(data);286 drop(data);295 return Err(create_error(Error::StackOverflow));287 throw!(StackOverflow);296 } else {288 } else {297 *stack_depth += 1;289 *stack_depth += 1;298 }290 }340 ManifestFormat::Json(padding) => val.into_json(padding)?,332 ManifestFormat::Json(padding) => val.into_json(padding)?,341 ManifestFormat::None => match val {333 ManifestFormat::None => match val {342 Val::Str(s) => s,334 Val::Str(s) => s,343 _ => return Err(create_error(Error::StringManifestOutputIsNotAString)),335 _ => throw!(StringManifestOutputIsNotAString),344 },336 },345 })337 })346 })338 })476#[cfg(test)]468#[cfg(test)]477pub mod tests {469pub mod tests {478 use super::Val;470 use super::Val;479 use crate::{create_error, primitive_equals, EvaluationState};471 use crate::{error::Error::*, primitive_equals, EvaluationState};480 use jrsonnet_parser::*;472 use jrsonnet_parser::*;481 use std::{path::PathBuf, rc::Rc};473 use std::{path::PathBuf, rc::Rc};482474493 state.push(485 state.push(494 &ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),486 &ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),495 || "inner".to_owned(),487 || "inner".to_owned(),496 || Err(create_error(crate::error::Error::RuntimeError("".into()))),488 || Err(RuntimeError("".into()).into()),497 )?;489 )?;498 Ok(())490 Ok(())499 },491 },crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth11 pub location: Option<ExprLocation>,11 pub location: Option<ExprLocation>,12}12}131314// Field => This15type CacheKey = (Rc<str>, usize);14#[derive(Debug)]16#[derive(Debug)]15pub struct ObjValueInternals {17pub struct ObjValueInternals {16 super_obj: Option<ObjValue>,18 super_obj: Option<ObjValue>,17 this_entries: Rc<HashMap<Rc<str>, ObjMember>>,19 this_entries: Rc<HashMap<Rc<str>, ObjMember>>,18 value_cache: RefCell<HashMap<(Rc<str>, usize), Option<Val>>>,20 value_cache: RefCell<HashMap<CacheKey, Option<Val>>>,19}21}20#[derive(Clone)]22#[derive(Clone)]21pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);23pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth1use crate::{1use crate::{2 create_error_result, evaluate,2 error::Error::*,3 evaluate,3 function::{parse_function_call, parse_function_call_map, place_args},4 function::{parse_function_call, parse_function_call_map, place_args},4 with_state, Context, Error, ObjValue, Result,5 throw, with_state, Context, ObjValue, Result,5};6};6use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};7use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};7use std::{8use std::{157 if num.is_finite() {158 if num.is_finite() {158 Ok(Val::Num(num))159 Ok(Val::Num(num))159 } else {160 } else {160 create_error_result(Error::RuntimeError("overflow".into()))161 throw!(RuntimeError("overflow".into()))161 }162 }162 }163 }163164164 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {165 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {165 let this_type = self.value_type()?;166 let this_type = self.value_type()?;166 if this_type != val_type {167 if this_type != val_type {167 create_error_result(Error::TypeMismatch(context, vec![val_type], this_type))168 throw!(TypeMismatch(context, vec![val_type], this_type))168 } else {169 } else {169 Ok(())170 Ok(())170 }171 }263 (Val::Null, Val::Null) => true,264 (Val::Null, Val::Null) => true,264 (Val::Str(a), Val::Str(b)) => a == b,265 (Val::Str(a), Val::Str(b)) => a == b,265 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,266 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,266 (Val::Arr(_), Val::Arr(_)) => create_error_result(Error::RuntimeError(267 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(267 "primitiveEquals operates on primitive types, got array".into(),268 "primitiveEquals operates on primitive types, got array".into(),268 ))?,269 )),269 (Val::Obj(_), Val::Obj(_)) => create_error_result(Error::RuntimeError(270 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(270 "primitiveEquals operates on primitive types, got object".into(),271 "primitiveEquals operates on primitive types, got object".into(),271 ))?,272 )),272 (a, b) if is_function_like(&a) && is_function_like(&b) => create_error_result(273 (a, b) if is_function_like(&a) && is_function_like(&b) => {273 Error::RuntimeError("cannot test equality of functions".into()),274 throw!(RuntimeError("cannot test equality of functions".into()))274 )?,275 }275 (_, _) => false,276 (_, _) => false,276 })277 })277}278}376 buf.push('}');377 buf.push('}');377 }378 }378 Val::Func(_) | Val::Intristic(_, _) => {379 Val::Func(_) | Val::Intristic(_, _) => {379 create_error_result(Error::RuntimeError("tried to manifest function".into()))?380 throw!(RuntimeError("tried to manifest function".into()))380 }381 }381 Val::Lazy(_) => unreachable!(),382 Val::Lazy(_) => unreachable!(),382 };383 };crates/jrsonnet-parser/src/expr.rsdiffbeforeafterboth258 /// importStr "file.txt"258 /// importStr "file.txt"259 ImportStr(PathBuf),259 ImportStr(PathBuf),260 /// error "I'm broken"260 /// error "I'm broken"261 Error(LocExpr),261 ErrorStmt(LocExpr),262 /// a(b, c)262 /// a(b, c)263 Apply(LocExpr, ArgsDesc, bool),263 Apply(LocExpr, ArgsDesc, bool),264 /// a[b]264 /// a[b]crates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth197 / l(s,<keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}>)197 / l(s,<keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}>)198 / l(s,<assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }>)198 / l(s,<assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }>)199199200 / l(s,<keyword("error") _ expr:expr(s) { Expr::Error(expr) }>)200 / l(s,<keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }>)201201202 rule slice_part(s: &ParserSettings) -> Option<LocExpr>202 rule slice_part(s: &ParserSettings) -> Option<LocExpr>203 = e:(_ e:expr(s) _{e})? {e}203 = e:(_ e:expr(s) _{e})? {e}