difftreelog
refactor reduce boilerplate by automatic conversions
in: master
29 files changed
bindings/jsonnet/src/native.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -69,10 +69,7 @@
ctx: *const c_void,
mut raw_params: *const *const c_char,
) {
- let name = CStr::from_ptr(name)
- .to_str()
- .expect("name is not utf-8")
- .into();
+ let name = CStr::from_ptr(name).to_str().expect("name is not utf-8");
let mut params = Vec::new();
loop {
if (*raw_params).is_null() {
bindings/jsonnet/src/val_make.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -5,10 +5,7 @@
os::raw::{c_char, c_double, c_int},
};
-use jrsonnet_evaluator::{
- val::{ArrValue, StrValue},
- ObjValue, Val,
-};
+use jrsonnet_evaluator::{val::ArrValue, ObjValue, Val};
use crate::VM;
@@ -21,7 +18,7 @@
pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {
let val = CStr::from_ptr(val);
let val = val.to_str().expect("string is not utf-8");
- Box::into_raw(Box::new(Val::Str(StrValue::Flat(val.into()))))
+ Box::into_raw(Box::new(Val::string(val)))
}
/// Convert the given double to a `JsonnetJsonValue`.
bindings/jsonnet/src/val_modify.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -5,7 +5,6 @@
use std::{ffi::CStr, os::raw::c_char};
use jrsonnet_evaluator::{val::ArrValue, Thunk, Val};
-use jrsonnet_gcmodule::Cc;
use crate::VM;
crates/jrsonnet-cli/src/stdlib.rsdiffbeforeafterboth--- a/crates/jrsonnet-cli/src/stdlib.rs
+++ b/crates/jrsonnet-cli/src/stdlib.rs
@@ -1,7 +1,7 @@
use std::{fs::read_to_string, str::FromStr};
use clap::Parser;
-use jrsonnet_evaluator::{error::Result, trace::PathResolver, State};
+use jrsonnet_evaluator::{trace::PathResolver, Result, State};
use jrsonnet_stdlib::ContextInitializer;
#[derive(Clone)]
crates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth1use std::{any::Any, cell::RefCell, fmt::Debug, iter, mem::replace};23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_parser::LocExpr;67use super::ArrValue;8use crate::{9 error::ErrorKind::InfiniteRecursionDetected,10 evaluate,11 function::FuncVal,12 typed::Typed,13 val::{StrValue, ThunkValue},14 Context, Error, ObjValue, Result, Thunk, Val,15};1617pub trait ArrayLike: Any + Trace + Debug {18 fn len(&self) -> usize;19 fn is_empty(&self) -> bool {20 self.len() == 021 }22 fn get(&self, index: usize) -> Result<Option<Val>>;23 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;24 fn get_cheap(&self, index: usize) -> Option<Val>;2526 fn is_cheap(&self) -> bool;27}2829#[derive(Debug, Trace)]30pub struct SliceArray {31 pub(crate) inner: ArrValue,32 pub(crate) from: u32,33 pub(crate) to: u32,34 pub(crate) step: u32,35}3637impl SliceArray {38 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {39 self.inner40 .iter()41 .skip(self.from as usize)42 .take((self.to - self.from) as usize)43 .step_by(self.step as usize)44 }4546 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {47 self.inner48 .iter_lazy()49 .skip(self.from as usize)50 .take((self.to - self.from) as usize)51 .step_by(self.step as usize)52 }5354 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {55 Some(56 self.inner57 .iter_cheap()?58 .skip(self.from as usize)59 .take((self.to - self.from) as usize)60 .step_by(self.step as usize),61 )62 }63}64impl ArrayLike for SliceArray {65 fn len(&self) -> usize {66 iter::repeat(())67 .take((self.to - self.from) as usize)68 .step_by(self.step as usize)69 .count()70 }7172 fn get(&self, index: usize) -> Result<Option<Val>> {73 self.iter().nth(index).transpose()74 }7576 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {77 self.iter_lazy().nth(index)78 }7980 fn get_cheap(&self, index: usize) -> Option<Val> {81 self.iter_cheap()?.nth(index)82 }83 fn is_cheap(&self) -> bool {84 self.inner.is_cheap()85 }86}8788#[derive(Trace, Debug)]89pub struct CharArray(pub Vec<char>);90impl ArrayLike for CharArray {91 fn len(&self) -> usize {92 self.0.len()93 }9495 fn get(&self, index: usize) -> Result<Option<Val>> {96 Ok(self.get_cheap(index))97 }9899 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {100 self.get_cheap(index).map(Thunk::evaluated)101 }102103 fn get_cheap(&self, index: usize) -> Option<Val> {104 self.0105 .get(index)106 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v))))107 }108 fn is_cheap(&self) -> bool {109 true110 }111}112113#[derive(Trace, Debug)]114pub struct BytesArray(pub IBytes);115impl ArrayLike for BytesArray {116 fn len(&self) -> usize {117 self.0.len()118 }119120 fn get(&self, index: usize) -> Result<Option<Val>> {121 Ok(self.get_cheap(index))122 }123124 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {125 self.get_cheap(index).map(Thunk::evaluated)126 }127128 fn get_cheap(&self, index: usize) -> Option<Val> {129 self.0.get(index).map(|v| Val::Num(f64::from(*v)))130 }131 fn is_cheap(&self) -> bool {132 true133 }134}135136#[derive(Debug, Trace, Clone)]137enum ArrayThunk<T: 'static + Trace> {138 Computed(Val),139 Errored(Error),140 Waiting(T),141 Pending,142}143144#[derive(Debug, Trace, Clone)]145pub struct ExprArray {146 ctx: Context,147 cached: Cc<RefCell<Vec<ArrayThunk<LocExpr>>>>,148}149impl ExprArray {150 pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {151 Self {152 ctx,153 cached: Cc::new(RefCell::new(154 items.into_iter().map(ArrayThunk::Waiting).collect(),155 )),156 }157 }158}159impl ArrayLike for ExprArray {160 fn len(&self) -> usize {161 self.cached.borrow().len()162 }163 fn get(&self, index: usize) -> Result<Option<Val>> {164 if index >= self.len() {165 return Ok(None);166 }167 match &self.cached.borrow()[index] {168 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),169 ArrayThunk::Errored(e) => return Err(e.clone()),170 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),171 ArrayThunk::Waiting(..) => {}172 };173174 let ArrayThunk::Waiting(expr) =175 replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)176 else {177 unreachable!()178 };179180 let new_value = match evaluate(self.ctx.clone(), &expr) {181 Ok(v) => v,182 Err(e) => {183 self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());184 return Err(e);185 }186 };187 self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());188 Ok(Some(new_value))189 }190 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {191 #[derive(Trace)]192 struct ArrayElement {193 arr_thunk: ExprArray,194 index: usize,195 }196197 impl ThunkValue for ArrayElement {198 type Output = Val;199200 fn get(self: Box<Self>) -> Result<Self::Output> {201 self.arr_thunk202 .get(self.index)203 .transpose()204 .expect("index checked")205 }206 }207208 if index >= self.len() {209 return None;210 }211 match &self.cached.borrow()[index] {212 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),213 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),214 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}215 };216217 Some(Thunk::new(ArrayElement {218 arr_thunk: self.clone(),219 index,220 }))221 }222 fn get_cheap(&self, _index: usize) -> Option<Val> {223 None224 }225 fn is_cheap(&self) -> bool {226 false227 }228}229230#[derive(Trace, Debug)]231pub struct ExtendedArray {232 pub a: ArrValue,233 pub b: ArrValue,234 split: usize,235 len: usize,236}237impl ExtendedArray {238 pub fn new(a: ArrValue, b: ArrValue) -> Self {239 let a_len = a.len();240 let b_len = b.len();241 Self {242 a,243 b,244 split: a_len,245 len: a_len.checked_add(b_len).expect("too large array value"),246 }247 }248}249250struct WithExactSize<I>(I, usize);251impl<I, T> Iterator for WithExactSize<I>252where253 I: Iterator<Item = T>,254{255 type Item = T;256257 fn next(&mut self) -> Option<Self::Item> {258 self.0.next()259 }260 fn nth(&mut self, n: usize) -> Option<Self::Item> {261 self.0.nth(n)262 }263 fn size_hint(&self) -> (usize, Option<usize>) {264 (self.1, Some(self.1))265 }266}267impl<I> DoubleEndedIterator for WithExactSize<I>268where269 I: DoubleEndedIterator,270{271 fn next_back(&mut self) -> Option<Self::Item> {272 self.0.next_back()273 }274 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {275 self.0.nth_back(n)276 }277}278impl<I> ExactSizeIterator for WithExactSize<I>279where280 I: Iterator,281{282 fn len(&self) -> usize {283 self.1284 }285}286impl ArrayLike for ExtendedArray {287 fn get(&self, index: usize) -> Result<Option<Val>> {288 if self.split > index {289 self.a.get(index)290 } else {291 self.b.get(index - self.split)292 }293 }294 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {295 if self.split > index {296 self.a.get_lazy(index)297 } else {298 self.b.get_lazy(index - self.split)299 }300 }301302 fn len(&self) -> usize {303 self.len304 }305306 fn get_cheap(&self, index: usize) -> Option<Val> {307 if self.split > index {308 self.a.get_cheap(index)309 } else {310 self.b.get_cheap(index - self.split)311 }312 }313 fn is_cheap(&self) -> bool {314 self.a.is_cheap() && self.b.is_cheap()315 }316}317318#[derive(Trace, Debug)]319pub struct LazyArray(pub Vec<Thunk<Val>>);320impl ArrayLike for LazyArray {321 fn len(&self) -> usize {322 self.0.len()323 }324 fn get(&self, index: usize) -> Result<Option<Val>> {325 let Some(v) = self.0.get(index) else {326 return Ok(None);327 };328 v.evaluate().map(Some)329 }330 fn get_cheap(&self, _index: usize) -> Option<Val> {331 None332 }333 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {334 self.0.get(index).cloned()335 }336 fn is_cheap(&self) -> bool {337 false338 }339}340341#[derive(Trace, Debug)]342pub struct EagerArray(pub Vec<Val>);343impl ArrayLike for EagerArray {344 fn len(&self) -> usize {345 self.0.len()346 }347348 fn get(&self, index: usize) -> Result<Option<Val>> {349 Ok(self.0.get(index).cloned())350 }351352 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {353 self.0.get(index).cloned().map(Thunk::evaluated)354 }355356 fn get_cheap(&self, index: usize) -> Option<Val> {357 self.0.get(index).cloned()358 }359 fn is_cheap(&self) -> bool {360 true361 }362}363364/// Inclusive range type365#[derive(Debug, Trace, PartialEq, Eq)]366pub struct RangeArray {367 start: i32,368 end: i32,369}370impl RangeArray {371 pub fn empty() -> Self {372 Self::new_exclusive(0, 0)373 }374 pub fn new_exclusive(start: i32, end: i32) -> Self {375 end.checked_sub(1)376 .map_or_else(Self::empty, |end| Self { start, end })377 }378 pub fn new_inclusive(start: i32, end: i32) -> Self {379 Self { start, end }380 }381 fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {382 WithExactSize(383 self.start..=self.end,384 (self.end as usize)385 .wrapping_sub(self.start as usize)386 .wrapping_add(1),387 )388 }389}390391impl ArrayLike for RangeArray {392 fn len(&self) -> usize {393 self.range().len()394 }395 fn is_empty(&self) -> bool {396 self.range().len() == 0397 }398399 fn get(&self, index: usize) -> Result<Option<Val>> {400 Ok(self.get_cheap(index))401 }402403 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {404 self.get_cheap(index).map(Thunk::evaluated)405 }406407 fn get_cheap(&self, index: usize) -> Option<Val> {408 self.range().nth(index).map(|i| Val::Num(f64::from(i)))409 }410 fn is_cheap(&self) -> bool {411 true412 }413}414415#[derive(Debug, Trace)]416pub struct ReverseArray(pub ArrValue);417impl ArrayLike for ReverseArray {418 fn len(&self) -> usize {419 self.0.len()420 }421422 fn get(&self, index: usize) -> Result<Option<Val>> {423 self.0.get(self.0.len() - index - 1)424 }425426 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {427 self.0.get_lazy(self.0.len() - index - 1)428 }429430 fn get_cheap(&self, index: usize) -> Option<Val> {431 self.0.get_cheap(self.0.len() - index - 1)432 }433 fn is_cheap(&self) -> bool {434 self.0.is_cheap()435 }436}437438#[derive(Trace, Debug, Clone)]439pub struct MappedArray {440 inner: ArrValue,441 cached: Cc<RefCell<Vec<ArrayThunk<()>>>>,442 mapper: FuncVal,443}444impl MappedArray {445 pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {446 let len = inner.len();447 Self {448 inner,449 cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting(()); len])),450 mapper,451 }452 }453}454impl ArrayLike for MappedArray {455 fn len(&self) -> usize {456 self.cached.borrow().len()457 }458459 fn get(&self, index: usize) -> Result<Option<Val>> {460 if index >= self.len() {461 return Ok(None);462 }463 match &self.cached.borrow()[index] {464 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),465 ArrayThunk::Errored(e) => return Err(e.clone()),466 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),467 ArrayThunk::Waiting(..) => {}468 };469470 let ArrayThunk::Waiting(_) =471 replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)472 else {473 unreachable!()474 };475476 let val = self477 .inner478 .get(index)479 .transpose()480 .expect("index checked")481 .and_then(|r| self.mapper.evaluate_simple(&(r,), false));482483 let new_value = match val {484 Ok(v) => v,485 Err(e) => {486 self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());487 return Err(e);488 }489 };490 self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());491 Ok(Some(new_value))492 }493 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {494 #[derive(Trace)]495 struct ArrayElement {496 arr_thunk: MappedArray,497 index: usize,498 }499500 impl ThunkValue for ArrayElement {501 type Output = Val;502503 fn get(self: Box<Self>) -> Result<Self::Output> {504 self.arr_thunk505 .get(self.index)506 .transpose()507 .expect("index checked")508 }509 }510511 if index >= self.len() {512 return None;513 }514 match &self.cached.borrow()[index] {515 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),516 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),517 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}518 };519520 Some(Thunk::new(ArrayElement {521 arr_thunk: self.clone(),522 index,523 }))524 }525526 fn get_cheap(&self, _index: usize) -> Option<Val> {527 None528 }529 fn is_cheap(&self) -> bool {530 false531 }532}533534#[derive(Trace, Debug)]535pub struct RepeatedArray {536 data: ArrValue,537 repeats: usize,538 total_len: usize,539}540impl RepeatedArray {541 pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {542 let total_len = data.len().checked_mul(repeats)?;543 Some(Self {544 data,545 repeats,546 total_len,547 })548 }549}550551impl ArrayLike for RepeatedArray {552 fn len(&self) -> usize {553 self.total_len554 }555556 fn get(&self, index: usize) -> Result<Option<Val>> {557 if index > self.total_len {558 return Ok(None);559 }560 self.data.get(index % self.data.len())561 }562563 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {564 if index > self.total_len {565 return None;566 }567 self.data.get_lazy(index % self.data.len())568 }569570 fn get_cheap(&self, index: usize) -> Option<Val> {571 if index > self.total_len {572 return None;573 }574 self.data.get_cheap(index % self.data.len())575 }576 fn is_cheap(&self) -> bool {577 self.data.is_cheap()578 }579}580581#[derive(Trace, Debug)]582pub struct PickObjectValues {583 obj: ObjValue,584 keys: Vec<IStr>,585}586587impl PickObjectValues {588 pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {589 Self { obj, keys }590 }591}592593impl ArrayLike for PickObjectValues {594 fn len(&self) -> usize {595 self.keys.len()596 }597598 fn get(&self, index: usize) -> Result<Option<Val>> {599 let Some(key) = self.keys.get(index) else {600 return Ok(None);601 };602 Ok(Some(self.obj.get_or_bail(key.clone())?))603 }604605 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {606 let Some(key) = self.keys.get(index) else {607 return None;608 };609 Some(self.obj.get_lazy_or_bail(key.clone()))610 }611612 fn get_cheap(&self, _index: usize) -> Option<Val> {613 None614 }615616 fn is_cheap(&self) -> bool {617 false618 }619}620621#[derive(Trace, Debug)]622pub struct PickObjectKeyValues {623 obj: ObjValue,624 keys: Vec<IStr>,625}626627impl PickObjectKeyValues {628 pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {629 Self { obj, keys }630 }631}632633#[derive(Typed)]634pub struct KeyValue {635 key: IStr,636 value: Thunk<Val>,637}638639impl ArrayLike for PickObjectKeyValues {640 fn len(&self) -> usize {641 self.keys.len()642 }643644 fn get(&self, index: usize) -> Result<Option<Val>> {645 let Some(key) = self.keys.get(index) else {646 return Ok(None);647 };648 Ok(Some(649 KeyValue::into_untyped(KeyValue {650 key: key.clone(),651 value: Thunk::evaluated(self.obj.get_or_bail(key.clone())?),652 })653 .expect("convertible"),654 ))655 }656657 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {658 let Some(key) = self.keys.get(index) else {659 return None;660 };661 // Nothing can fail in the key part, yet value is still662 // lazy-evaluated663 Some(Thunk::evaluated(664 KeyValue::into_untyped(KeyValue {665 key: key.clone(),666 value: self.obj.get_lazy_or_bail(key.clone()),667 })668 .expect("convertible"),669 ))670 }671672 fn get_cheap(&self, _index: usize) -> Option<Val> {673 None674 }675676 fn is_cheap(&self) -> bool {677 false678 }679}crates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -87,9 +87,9 @@
}
#[must_use]
- pub fn with_var(self, name: IStr, value: Val) -> Self {
+ pub fn with_var(self, name: impl Into<IStr>, value: Val) -> Self {
let mut new_bindings = GcHashMap::with_capacity(1);
- new_bindings.insert(name, Thunk::evaluated(value));
+ new_bindings.insert(name.into(), Thunk::evaluated(value));
self.extend(new_bindings, None, None, None)
}
@@ -161,8 +161,8 @@
}
/// # Panics
/// If `name` is already bound
- pub fn bind(&mut self, name: IStr, value: Thunk<Val>) -> &mut Self {
- let old = self.bindings.insert(name, value);
+ pub fn bind(&mut self, name: impl Into<IStr>, value: Thunk<Val>) -> &mut Self {
+ let old = self.bindings.insert(name.into(), value);
assert!(old.is_none(), "variable bound twice in single context call");
self
}
crates/jrsonnet-evaluator/src/dynamic.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -52,9 +52,3 @@
Self::new()
}
}
-
-impl<T: Trace + Clone> From<Pending<T>> for Thunk<T> {
- fn from(value: Pending<T>) -> Self {
- Self::new(value)
- }
-}
crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -36,7 +36,7 @@
}
}
Some(match &*expr.0 {
- Expr::Str(s) => Val::Str(StrValue::Flat(s.clone())),
+ Expr::Str(s) => Val::string(s.clone()),
Expr::Num(n) => Val::Num(*n),
Expr::Literal(LiteralType::False) => Val::Bool(false),
Expr::Literal(LiteralType::True) => Val::Bool(true),
@@ -135,7 +135,7 @@
let fctx = Pending::new();
let mut new_bindings = GcHashMap::with_capacity(var.capacity_hint());
let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
- Thunk::evaluated(Val::Str(StrValue::Flat(field.clone()))),
+ Thunk::evaluated(Val::string(field.clone())),
Thunk::new(ObjectFieldThunk {
field: field.clone(),
obj: obj.clone(),
@@ -226,7 +226,7 @@
}
builder
- .member(name.clone())
+ .field(name.clone())
.with_add(*plus)
.with_visibility(*visibility)
.with_location(value.1.clone())
@@ -262,7 +262,7 @@
}
builder
- .member(name.clone())
+ .field(name.clone())
.with_visibility(*visibility)
.with_location(value.1.clone())
.bindable(UnboundMethod {
@@ -437,7 +437,7 @@
Literal(LiteralType::False) => Val::Bool(false),
Literal(LiteralType::Null) => Val::Null,
Parened(e) => evaluate(ctx, e)?,
- Str(v) => Val::Str(StrValue::Flat(v.clone())),
+ Str(v) => Val::string(v.clone()),
Num(v) => Val::new_checked_num(*v)?,
BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,
UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
@@ -672,7 +672,7 @@
|| format!("import {:?}", path.clone()),
|| s.import_resolved(resolved_path),
)?,
- ImportStr(_) => Val::Str(StrValue::Flat(s.import_resolved_str(resolved_path)?)),
+ ImportStr(_) => Val::string(s.import_resolved_str(resolved_path)?),
ImportBin(_) => Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?)),
_ => unreachable!(),
}
crates/jrsonnet-evaluator/src/evaluate/operator.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -30,18 +30,12 @@
Ok(match (a, b) {
(Str(v1), Str(v2)) => Str(StrValue::concat(v1.clone(), v2.clone())),
- (Num(a), Str(b)) => Str(StrValue::Flat(format!("{a}{b}").into())),
- (Str(a), Num(b)) => Str(StrValue::Flat(format!("{a}{b}").into())),
+ (Num(a), Str(b)) => Val::string(format!("{a}{b}")),
+ (Str(a), Num(b)) => Val::string(format!("{a}{b}")),
- (Str(a), o) | (o, Str(a)) if a.is_empty() => {
- Val::Str(StrValue::Flat(o.clone().to_string()?))
- }
- (Str(a), o) => Str(StrValue::Flat(
- format!("{a}{}", o.clone().to_string()?).into(),
- )),
- (o, Str(a)) => Str(StrValue::Flat(
- format!("{}{a}", o.clone().to_string()?).into(),
- )),
+ (Str(a), o) | (o, Str(a)) if a.is_empty() => Val::string(o.clone().to_string()?),
+ (Str(a), o) => Val::string(format!("{a}{}", o.clone().to_string()?)),
+ (o, Str(a)) => Val::string(format!("{}{a}", o.clone().to_string()?)),
(Obj(v1), Obj(v2)) => Obj(v2.extend_from(v1.clone())),
(Arr(a), Arr(b)) => Val::Arr(ArrValue::extended(a.clone(), b.clone())),
@@ -149,7 +143,7 @@
(Str(a), In, Obj(obj)) => Bool(obj.has_field_ex(a.clone().into_flat(), true)),
(a, Mod, b) => evaluate_mod_op(a, b)?,
- (Str(v1), Mul, Num(v2)) => Str(StrValue::Flat(v1.to_string().repeat(*v2 as usize).into())),
+ (Str(v1), Mul, Num(v2)) => Val::string(v1.to_string().repeat(*v2 as usize)),
// Bool X Bool
(Bool(a), And, Bool(b)) => Bool(*a && *b),
crates/jrsonnet-evaluator/src/function/arglike.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -61,7 +61,7 @@
impl ArgLike for TlaArg {
fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
match self {
- TlaArg::String(s) => Ok(Thunk::evaluated(Val::Str(StrValue::Flat(s.clone())))),
+ TlaArg::String(s) => Ok(Thunk::evaluated(Val::string(s.clone()))),
TlaArg::Code(code) => Ok(if tailstrict {
Thunk::evaluated(evaluate(ctx, code)?)
} else {
crates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -12,7 +12,10 @@
native::NativeDesc,
parse::{parse_default_function_call, parse_function_call},
};
-use crate::{evaluate, evaluate_trivial, gc::TraceBox, tb, Context, ContextBuilder, Result, Val};
+use crate::{
+ evaluate, evaluate_trivial, gc::TraceBox, tb, Context, ContextBuilder, Result,
+ Val,
+};
pub mod arglike;
pub mod builtin;
@@ -124,6 +127,9 @@
pub fn builtin(builtin: impl Builtin) -> Self {
Self::Builtin(Cc::new(tb!(builtin)))
}
+ pub fn static_builtin(static_builtin: &'static dyn StaticBuiltin) -> Self {
+ Self::StaticBuiltin(static_builtin)
+ }
pub fn params(&self) -> Vec<BuiltinParam> {
match self {
@@ -239,3 +245,17 @@
}
}
}
+
+impl<T> From<T> for FuncVal
+where
+ T: Builtin,
+{
+ fn from(value: T) -> Self {
+ Self::builtin(value)
+ }
+}
+impl From<&'static dyn StaticBuiltin> for FuncVal {
+ fn from(value: &'static dyn StaticBuiltin) -> Self {
+ Self::static_builtin(value)
+ }
+}
crates/jrsonnet-evaluator/src/function/native.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/native.rs
+++ b/crates/jrsonnet-evaluator/src/function/native.rs
@@ -2,7 +2,7 @@
arglike::{ArgLike, OptionalContext},
FuncVal,
};
-use crate::{error::Result, typed::Typed};
+use crate::{typed::Typed, Result};
pub trait NativeDesc {
type Value;
crates/jrsonnet-evaluator/src/gc.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/gc.rs
+++ b/crates/jrsonnet-evaluator/src/gc.rs
@@ -117,9 +117,7 @@
}
#[derive(Debug)]
-pub struct GcHashMap<K, V>(
- pub HashMap<K, V, BuildHasherDefault<FxHasher>>
-);
+pub struct GcHashMap<K, V>(pub HashMap<K, V, BuildHasherDefault<FxHasher>>);
impl<K, V> GcHashMap<K, V> {
pub fn new() -> Self {
Self(HashMap::default())
crates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -11,10 +11,8 @@
};
use crate::{
- arr::ArrValue,
- error::{Error as JrError, ErrorKind, Result},
- val::StrValue,
- ObjValue, ObjValueBuilder, State, Val,
+ arr::ArrValue, runtime_error, Error as JrError, ObjValue, ObjValueBuilder,
+ Result, State, Val,
};
impl<'de> Deserialize<'de> for Val {
@@ -57,7 +55,7 @@
where
E: serde::de::Error,
{
- Ok(Val::Str(StrValue::Flat(v.into())))
+ Ok(Val::string(v))
}
// visit_num! {
@@ -138,7 +136,7 @@
while let Some((k, v)) = map.next_entry::<Cow<'de, str>, Val>()? {
// Jsonnet ignores duplicate keys
- out.member(k.into()).value_unchecked(v);
+ out.field(k).value(v);
}
Ok(Val::Obj(out.build()))
@@ -264,7 +262,7 @@
let inner = Val::Arr(ArrValue::eager(self.data));
if let Some(variant) = self.variant {
let mut out = ObjValue::builder_with_capacity(1);
- out.member(variant).value_unchecked(inner);
+ out.field(variant).value(inner);
Ok(Val::Obj(out.build()))
} else {
Ok(inner)
@@ -365,7 +363,7 @@
{
let key = self.key.take().expect("no serialize_key called");
let value = value.serialize(IntoValSerializer)?;
- self.data.member(key).value(value)?;
+ self.data.field(key).try_value(value)?;
Ok(())
}
@@ -378,7 +376,7 @@
let key = key.serialize(IntoValSerializer)?;
let key = key.to_string()?;
let value = value.serialize(IntoValSerializer)?;
- self.data.member(key).value(value)?;
+ self.data.field(key).try_value(value)?;
Ok(())
}
@@ -386,7 +384,7 @@
let inner = Val::Obj(self.data.build());
if let Some(variant) = self.variant {
let mut out = ObjValue::builder_with_capacity(1);
- out.member(variant).value_unchecked(inner);
+ out.field(variant).value(inner);
Ok(Val::Obj(out.build()))
} else {
Ok(inner)
@@ -550,7 +548,7 @@
{
let mut out = ObjValue::builder_with_capacity(1);
let value = value.serialize(self)?;
- out.member(variant.into()).value_unchecked(value);
+ out.field(variant).value(value);
Ok(Val::Obj(out.build()))
}
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -498,7 +498,7 @@
pub struct InitialUnderscore(pub Thunk<Val>);
impl ContextInitializer for InitialUnderscore {
fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
- builder.bind("_".into(), self.0.clone());
+ builder.bind("_", self.0.clone());
}
fn as_any(&self) -> &dyn Any {
crates/jrsonnet-evaluator/src/manifest.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/manifest.rs
@@ -174,11 +174,13 @@
Val::Str(s) => escape_string_json_buf(&s.clone().into_flat(), buf),
Val::Num(n) => write!(buf, "{n}").unwrap(),
#[cfg(feature = "exp-bigint")]
- Val::BigInt(n) => if options.preserve_bigints {
- write!(buf, "{n}").unwrap()
- } else {
- write!(buf, "{:?}", n.to_string()).unwrap()
- },
+ Val::BigInt(n) => {
+ if options.preserve_bigints {
+ write!(buf, "{n}").unwrap()
+ } else {
+ write!(buf, "{:?}", n.to_string()).unwrap()
+ }
+ }
Val::Arr(items) => {
buf.push('[');
if !items.is_empty() {
crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -15,7 +15,7 @@
arr::{PickObjectKeyValues, PickObjectValues},
bail,
error::{suggest_object_fields, Error, ErrorKind::*},
- function::CallLocation,
+ function::{CallLocation, FuncVal},
gc::{GcHashMap, GcHashSet, TraceBox},
operator::evaluate_add_op,
tb,
@@ -345,7 +345,7 @@
pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {
let mut out = ObjValueBuilder::with_capacity(1);
out.with_super(self);
- let mut member = out.member(key);
+ let mut member = out.field(key);
if value.flags.add() {
member = member.add()
}
@@ -848,11 +848,27 @@
self.assertions.push(tb!(assertion));
self
}
- pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {
+ pub fn field(&mut self, name: impl Into<IStr>) -> ObjMemberBuilder<ValueBuilder<'_>> {
let field_index = self.next_field_index;
self.next_field_index = self.next_field_index.next();
- ObjMemberBuilder::new(ValueBuilder(self), name, field_index)
+ ObjMemberBuilder::new(ValueBuilder(self), name.into(), field_index)
}
+ /// Preset for common method definiton pattern:
+ /// Create a hidden field with the function value.
+ ///
+ /// `.field(name).hide().value(Val::function(value))`
+ pub fn method(&mut self, name: impl Into<IStr>, value: impl Into<FuncVal>) -> &mut Self {
+ self.field(name).hide().value(Val::Func(value.into()));
+ self
+ }
+ pub fn try_method(
+ &mut self,
+ name: impl Into<IStr>,
+ value: impl Into<FuncVal>,
+ ) -> Result<&mut Self> {
+ self.field(name).hide().try_value(Val::Func(value.into()))?;
+ Ok(self)
+ }
pub fn build(self) -> ObjValue {
if self.sup.is_none() && self.map.is_empty() && self.assertions.is_empty() {
@@ -930,18 +946,19 @@
pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);
impl ObjMemberBuilder<ValueBuilder<'_>> {
/// Inserts value, replacing if it is already defined
- pub fn value_unchecked(self, value: Val) {
+ pub fn value(self, value: impl Into<Val>) {
let (receiver, name, member) =
- self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value)));
+ self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value.into())));
let entry = receiver.0.map.entry(name);
entry.insert(member);
}
- pub fn value(self, value: Val) -> Result<()> {
- self.thunk(Thunk::evaluated(value))
+ /// Tries to insert value, returns an error if it was already defined
+ pub fn try_value(self, value: impl Into<Val>) -> Result<()> {
+ self.thunk(Thunk::evaluated(value.into()))
}
- pub fn thunk(self, value: Thunk<Val>) -> Result<()> {
- self.binding(MaybeUnbound::Bound(value))
+ pub fn thunk(self, value: impl Into<Thunk<Val>>) -> Result<()> {
+ self.binding(MaybeUnbound::Bound(value.into()))
}
pub fn bindable(self, bindable: impl Unbound<Bound = Val>) -> Result<()> {
self.binding(MaybeUnbound::Unbound(Cc::new(tb!(bindable))))
@@ -963,8 +980,8 @@
pub struct ExtendBuilder<'v>(&'v mut ObjValue);
impl ObjMemberBuilder<ExtendBuilder<'_>> {
- pub fn value(self, value: Val) {
- self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));
+ pub fn value(self, value: impl Into<Val>) {
+ self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));
}
pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Val>>) {
self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));
crates/jrsonnet-evaluator/src/typed/conversions.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -276,7 +276,7 @@
const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
fn into_untyped(value: Self) -> Result<Val> {
- Ok(Val::Str(StrValue::Flat(value)))
+ Ok(Val::string(value))
}
fn from_untyped(value: Val) -> Result<Self> {
@@ -292,7 +292,7 @@
const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
fn into_untyped(value: Self) -> Result<Val> {
- Ok(Val::Str(StrValue::Flat(value.into())))
+ Ok(Val::string(value))
}
fn from_untyped(value: Val) -> Result<Self> {
@@ -308,7 +308,7 @@
const TYPE: &'static ComplexValType = &ComplexValType::Char;
fn into_untyped(value: Self) -> Result<Val> {
- Ok(Val::Str(StrValue::Flat(value.to_string().into())))
+ Ok(Val::string(value))
}
fn from_untyped(value: Val) -> Result<Self> {
@@ -356,7 +356,7 @@
bail!("map key should serialize to string");
};
let value = V::into_untyped(v)?;
- out.member(key).value_unchecked(value);
+ out.field(key).value(value);
}
Ok(Val::Obj(out.build()))
}
@@ -611,7 +611,7 @@
fn into_untyped(value: Self) -> Result<Val> {
match value {
- IndexableVal::Str(s) => Ok(Val::Str(StrValue::Flat(s))),
+ IndexableVal::Str(s) => Ok(Val::string(s)),
IndexableVal::Arr(a) => Ok(Val::Arr(a)),
}
}
crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -142,6 +142,14 @@
}
}
}
+impl<T, V: Trace> From<T> for Thunk<V>
+where
+ T: ThunkValue<Output = V>,
+{
+ fn from(value: T) -> Self {
+ Thunk::new(value)
+ }
+}
impl<T: Trace + Default> Default for Thunk<T> {
fn default() -> Self {
@@ -323,21 +331,14 @@
}
}
}
-impl From<&str> for StrValue {
- fn from(value: &str) -> Self {
- Self::Flat(value.into())
- }
-}
-impl From<String> for StrValue {
- fn from(value: String) -> Self {
- Self::Flat(value.into())
+impl<T> From<T> for StrValue
+where
+ IStr: From<T>,
+{
+ fn from(value: T) -> Self {
+ Self::Flat(IStr::from(value))
}
}
-impl From<IStr> for StrValue {
- fn from(value: IStr) -> Self {
- Self::Flat(value)
- }
-}
impl Display for StrValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
@@ -401,7 +402,7 @@
impl From<IndexableVal> for Val {
fn from(v: IndexableVal) -> Self {
match v {
- IndexableVal::Str(s) => Self::Str(StrValue::Flat(s)),
+ IndexableVal::Str(s) => Self::string(s),
IndexableVal::Arr(a) => Self::Arr(a),
}
}
@@ -499,6 +500,34 @@
_ => bail!(ValueIsNotIndexable(self.value_type())),
})
}
+
+ pub fn function(function: impl Into<FuncVal>) -> Self {
+ Self::Func(function.into())
+ }
+ pub fn string(string: impl Into<StrValue>) -> Self {
+ Self::Str(string.into())
+ }
+}
+
+impl From<IStr> for Val {
+ fn from(value: IStr) -> Self {
+ Self::string(value)
+ }
+}
+impl From<String> for Val {
+ fn from(value: String) -> Self {
+ Self::string(value)
+ }
+}
+impl From<&str> for Val {
+ fn from(value: &str) -> Self {
+ Self::string(value)
+ }
+}
+impl From<ObjValue> for Val {
+ fn from(value: ObjValue) -> Self {
+ Self::Obj(value)
+ }
}
const fn is_function_like(val: &Val) -> bool {
crates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -567,18 +567,18 @@
if self.is_option {
quote! {
if let Some(value) = self.#ident {
- out.member(#name.into())
+ out.field(#name)
#hide
#add
- .value(<#ty as Typed>::into_untyped(value)?)?;
+ .try_value(<#ty as Typed>::into_untyped(value)?)?;
}
}
} else {
quote! {
- out.member(#name.into())
+ out.field(#name)
#hide
#add
- .value(<#ty as Typed>::into_untyped(self.#ident)?)?;
+ .try_value(<#ty as Typed>::into_untyped(self.#ident)?)?;
}
}
} else if self.is_option {
crates/jrsonnet-stdlib/src/arrays.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -36,7 +36,7 @@
#[builtin]
pub fn builtin_repeat(what: Either![IStr, ArrValue], count: usize) -> Result<Val> {
Ok(match what {
- Either2::A(s) => Val::Str(StrValue::Flat(s.repeat(count).into())),
+ Either2::A(s) => Val::string(s.repeat(count)),
Either2::B(arr) => Val::Arr(
ArrValue::repeated(arr, count)
.ok_or_else(|| runtime_error!("repeated length overflow"))?,
crates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -6,13 +6,12 @@
use jrsonnet_evaluator::{
error::{ErrorKind::*, Result},
- function::{builtin::Builtin, CallLocation, FuncVal, TlaArg},
- gc::TraceBox,
+ function::{CallLocation, FuncVal, TlaArg},
tb,
trace::PathResolver,
ContextBuilder, IStr, ObjValue, ObjValueBuilder, State, Thunk, Val,
};
-use jrsonnet_gcmodule::{Cc, Trace};
+use jrsonnet_gcmodule::Trace;
use jrsonnet_parser::Source;
mod expr;
@@ -182,38 +181,24 @@
.iter()
.cloned()
{
- builder
- .member(name.into())
- .hide()
- .value(Val::Func(FuncVal::StaticBuiltin(builtin)))
- .expect("no conflict");
+ builder.method(name, builtin);
}
- builder
- .member("extVar".into())
- .hide()
- .value(Val::Func(FuncVal::builtin(builtin_ext_var {
+ builder.method(
+ "extVar",
+ builtin_ext_var {
settings: settings.clone(),
- })))
- .expect("no conflict");
- builder
- .member("native".into())
- .hide()
- .value(Val::Func(FuncVal::builtin(builtin_native {
+ },
+ );
+ builder.method(
+ "native",
+ builtin_native {
settings: settings.clone(),
- })))
- .expect("no conflict");
- builder
- .member("trace".into())
- .hide()
- .value(Val::Func(FuncVal::builtin(builtin_trace { settings })))
- .expect("no conflict");
+ },
+ );
+ builder.method("trace", builtin_trace { settings });
- builder
- .member("id".into())
- .hide()
- .value(Val::Func(FuncVal::Id))
- .expect("no conflict");
+ builder.method("id", FuncVal::Id);
builder.build()
}
@@ -293,7 +278,7 @@
#[cfg(not(feature = "legacy-this-file"))]
context: {
let mut context = ContextBuilder::with_capacity(_s, 1);
- context.bind("std".into(), stdlib_thunk.clone());
+ context.bind("std", stdlib_thunk.clone());
context.build()
},
#[cfg(not(feature = "legacy-this-file"))]
@@ -338,10 +323,10 @@
.insert(name.into(), TlaArg::Code(parsed));
Ok(())
}
- pub fn add_native(&self, name: IStr, cb: impl Builtin) {
+ pub fn add_native(&self, name: impl Into<IStr>, cb: impl Into<FuncVal>) {
self.settings_mut()
.ext_natives
- .insert(name, Cc::new(tb!(cb)));
+ .insert(name.into(), cb.into());
}
}
impl jrsonnet_evaluator::ContextInitializer for ContextInitializer {
@@ -354,7 +339,7 @@
}
#[cfg(not(feature = "legacy-this-file"))]
fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
- builder.bind("std".into(), self.stdlib_thunk.clone());
+ builder.bind("std", self.stdlib_thunk.clone());
}
#[cfg(feature = "legacy-this-file")]
fn populate(&self, source: Source, builder: &mut ContextBuilder) {
@@ -362,14 +347,14 @@
let mut std = ObjValueBuilder::new();
std.with_super(self.stdlib_obj.clone());
- std.member("thisFile".into())
+ std.field("thisFile".into())
.hide()
- .value(Val::Str(StrValue::Flat(
+ .value(Val::string(
match source.source_path().path() {
Some(p) => self.settings().path_resolver.resolve(p).into(),
None => source.source_path().to_string().into(),
},
- )))
+ ))
.expect("this object builder is empty");
let stdlib_with_this_file = std.build();
crates/jrsonnet-stdlib/src/misc.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/misc.rs
+++ b/crates/jrsonnet-stdlib/src/misc.rs
@@ -47,7 +47,7 @@
.ext_natives
.get(&x)
.cloned()
- .map_or(Val::Null, |v| Val::Func(FuncVal::Builtin(v)))
+ .map_or(Val::Null, |v| Val::Func(v))
}
#[builtin(fields(
crates/jrsonnet-stdlib/src/objects.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/objects.rs
+++ b/crates/jrsonnet-stdlib/src/objects.rs
@@ -122,7 +122,7 @@
if k == key {
continue;
}
- new_obj.member(k).value_unchecked(v.unwrap())
+ new_obj.field(k).value(v.unwrap())
}
new_obj.build()
crates/jrsonnet-stdlib/src/operator.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/operator.rs
+++ b/crates/jrsonnet-stdlib/src/operator.rs
@@ -16,7 +16,7 @@
evaluate_mod_op(
&match a {
A(v) => Val::Num(v),
- B(s) => Val::Str(StrValue::Flat(s)),
+ B(s) => Val::string(s),
},
&b,
)
crates/jrsonnet-stdlib/src/sets.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/sets.rs
+++ b/crates/jrsonnet-stdlib/src/sets.rs
@@ -1,11 +1,10 @@
use std::cmp::Ordering;
use jrsonnet_evaluator::{
- error::Result,
function::{builtin, FuncVal},
operator::evaluate_compare_op,
val::ArrValue,
- Thunk, Val,
+ Result, Thunk, Val,
};
use jrsonnet_parser::BinaryOpType;
@@ -108,7 +107,7 @@
}
};
}
- while let Some(ac) = &ak {
+ while let Some(_ac) = &ak {
// In a, but not in b
out.push(av.clone().expect("ak != None"));
av = a.next();
crates/jrsonnet-stdlib/src/strings.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/strings.rs
+++ b/crates/jrsonnet-stdlib/src/strings.rs
@@ -3,7 +3,7 @@
error::{ErrorKind::*, Result},
function::builtin,
typed::{Either2, M1},
- val::{ArrValue, StrValue},
+ val::ArrValue,
Either, IStr, Val,
};
@@ -41,14 +41,8 @@
pub fn builtin_splitlimit(str: IStr, c: IStr, maxsplits: Either![usize, M1]) -> ArrValue {
use Either2::*;
match maxsplits {
- A(n) => str
- .splitn(n + 1, &c as &str)
- .map(|s| Val::Str(StrValue::Flat(s.into())))
- .collect(),
- B(_) => str
- .split(&c as &str)
- .map(|s| Val::Str(StrValue::Flat(s.into())))
- .collect(),
+ A(n) => str.splitn(n + 1, &c as &str).map(Val::string).collect(),
+ B(_) => str.split(&c as &str).map(Val::string).collect(),
}
}
tests/tests/builtin.rsdiffbeforeafterboth--- a/tests/tests/builtin.rs
+++ b/tests/tests/builtin.rs
@@ -36,7 +36,7 @@
s.with_stdlib();
s.add_global(
"nativeAdd".into(),
- Thunk::evaluated(Val::Func(FuncVal::StaticBuiltin(native_add::INST))),
+ Thunk::evaluated(Val::function(native_add::INST)),
);
let v = s.evaluate_snippet(
@@ -69,7 +69,7 @@
s.with_stdlib();
s.add_global(
"curryAdd".into(),
- Thunk::evaluated(Val::Func(FuncVal::StaticBuiltin(curry_add::INST))),
+ Thunk::evaluated(Val::function(curry_add::INST)),
);
let v = s.evaluate_snippet(
tests/tests/common.rsdiffbeforeafterboth--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -77,12 +77,8 @@
#[allow(dead_code)]
pub fn with_test(s: &State) {
let mut bobj = ObjValueBuilder::new();
- bobj.member("assertThrow".into())
- .hide()
- .value_unchecked(Val::Func(FuncVal::StaticBuiltin(assert_throw::INST)));
- bobj.member("paramNames".into())
- .hide()
- .value_unchecked(Val::Func(FuncVal::StaticBuiltin(param_names::INST)));
+ bobj.method("assertThrow", assert_throw::INST);
+ bobj.method("paramNames", param_names::INST);
s.add_global("test".into(), Thunk::evaluated(Val::Obj(bobj.build())))
}