difftreelog
feat return NumValue directly from parser
in: master
15 files changed
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::{
- ObjValue, Val,
- val::{ArrValue, NumValue},
-};
+use jrsonnet_evaluator::{NumValue, ObjValue, Val};
use crate::VM;
crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -2,7 +2,9 @@
use jrsonnet_gcmodule::{Acyclic, Trace};
use jrsonnet_interner::IStr;
-use jrsonnet_ir::{BinaryOpType, Source, SourcePath, Span, Spanned, UnaryOpType};
+use jrsonnet_ir::{
+ BinaryOpType, ConvertNumValueError, Source, SourcePath, Span, Spanned, UnaryOpType,
+};
use jrsonnet_types::ValType;
use thiserror::Error;
@@ -11,7 +13,6 @@
function::{CallLocation, FunctionSignature, ParamName},
stdlib::format::FormatError,
typed::TypeLocError,
- val::ConvertNumValueError,
};
#[derive(Debug, Clone)]
@@ -228,6 +229,11 @@
Self::new(e)
}
}
+impl From<ConvertNumValueError> for Error {
+ fn from(e: ConvertNumValueError) -> Self {
+ Self::new(ErrorKind::ConvertNumValue(e))
+ }
+}
impl From<Infallible> for Error {
fn from(_value: Infallible) -> Self {
crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -21,7 +21,7 @@
function::{CallLocation, FuncDesc, FuncVal, PreparedFuncVal},
in_frame,
typed::{FromUntyped, IntoUntyped as _, Typed},
- val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},
+ val::{CachedUnbound, IndexableVal, StrValue, Thunk},
with_state,
};
pub mod destructure;
@@ -58,9 +58,7 @@
}
Some(match expr {
Expr::Str(s) => Val::string(s.clone()),
- Expr::Num(n) => {
- Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))
- }
+ Expr::Num(n) => Val::Num(*n),
Expr::Literal(LiteralType::False) => Val::Bool(false),
Expr::Literal(LiteralType::True) => Val::Bool(true),
Expr::Literal(LiteralType::Null) => Val::Null,
crates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth1use std::borrow::Cow;23use jrsonnet_interner::{IBytes, IStr};4use jrsonnet_ir::NumValue;5use serde::{6 Deserialize, Serialize, Serializer,7 de::{self, Visitor},8 ser::{9 Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,10 SerializeTupleStruct, SerializeTupleVariant,11 },12};1314use crate::{15 Error as JrError, ObjValue, ObjValueBuilder, Result, Val, in_description_frame, runtime_error,16};1718impl<'de> Deserialize<'de> for Val {19 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>20 where21 D: serde::Deserializer<'de>,22 {23 struct ValVisitor;2425 // macro_rules! visit_num {26 // ($($method:ident => $ty:ty),* $(,)?) => {$(27 // fn $method<E>(self, v: $ty) -> Result<Self::Value, E>28 // where29 // E: serde::de::Error,30 // {31 // Ok(Val::Num(f64::from(v)))32 // }33 // )*};34 // }3536 impl<'de> Visitor<'de> for ValVisitor {37 type Value = Val;3839 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>40 where41 E: de::Error,42 {43 Ok(Val::Bool(v))44 }45 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>46 where47 E: de::Error,48 {49 Ok(Val::Num(NumValue::new(v).ok_or_else(|| {50 E::custom("only finite numbers are supported")51 })?))52 }53 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>54 where55 E: de::Error,56 {57 Ok(Val::string(v))58 }5960 // visit_num! {61 // visit_i8 => i8,62 // visit_i16 => i16,63 // visit_i32 => i32,64 // visit_u8 => u8,65 // visit_u16 => u16,66 // visit_u32 => u32,67 // }68 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>69 where70 E: de::Error,71 {72 #[expect(73 clippy::cast_precision_loss,74 reason = "this is how it works with stdlib functions"75 )]76 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))77 }78 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>79 where80 E: de::Error,81 {82 #[expect(83 clippy::cast_precision_loss,84 reason = "this is how it works with stdlib functions"85 )]86 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))87 }8889 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>90 where91 E: de::Error,92 {93 Ok(Val::arr(IBytes::from(v)))94 }9596 fn visit_none<E>(self) -> Result<Self::Value, E>97 where98 E: de::Error,99 {100 Ok(Val::Null)101 }102 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>103 where104 D: serde::Deserializer<'de>,105 {106 deserializer.deserialize_any(self)107 }108109 fn visit_unit<E>(self) -> Result<Self::Value, E>110 where111 E: de::Error,112 {113 Ok(Val::Null)114 }115116 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>117 where118 D: serde::Deserializer<'de>,119 {120 deserializer.deserialize_any(self)121 }122123 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>124 where125 A: de::SeqAccess<'de>,126 {127 let mut out = seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);128129 while let Some(val) = seq.next_element::<Val>()? {130 out.push(val);131 }132133 Ok(Val::arr(out))134 }135136 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>137 where138 A: de::MapAccess<'de>,139 {140 let mut out = map141 .size_hint()142 .map_or_else(ObjValueBuilder::new, ObjValueBuilder::with_capacity);143144 while let Some((k, v)) = map.next_entry::<Cow<'de, str>, Val>()? {145 // Jsonnet ignores duplicate keys146 out.field(k).value(v);147 }148149 Ok(Val::Obj(out.build()))150 }151152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {153 write!(formatter, "any valid jsonnet value")154 }155 }156 deserializer.deserialize_any(ValVisitor)157 }158}159160impl Serialize for Val {161 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>162 where163 S: serde::Serializer,164 {165 match self {166 Self::Bool(v) => serializer.serialize_bool(*v),167 Self::Null => serializer.serialize_none(),168 Self::Str(s) => serializer.serialize_str(&s.clone().into_flat()),169 Self::Num(n) => {170 let n = n.get();171 if n.fract() == 0.0 {172 #[expect(173 clippy::cast_possible_truncation,174 reason = "no correct implementation is possible here; expected"175 )]176 let n = n as i64;177 serializer.serialize_i64(n)178 } else {179 serializer.serialize_f64(n)180 }181 }182 #[cfg(feature = "exp-bigint")]183 Self::BigInt(b) => b.serialize(serializer),184 Self::Arr(arr) => {185 let mut seq = serializer.serialize_seq(Some(arr.len()))?;186 for (i, element) in arr.iter().enumerate() {187 let mut serde_error = None;188 in_description_frame(189 || format!("array index [{i}]"),190 || {191 let e = element?;192 if let Err(e) = seq.serialize_element(&e) {193 serde_error = Some(e);194 }195 Ok(())196 },197 )198 .map_err(|e| S::Error::custom(e.to_string()))?;199 if let Some(e) = serde_error {200 return Err(e);201 }202 }203 seq.end()204 }205 Self::Obj(obj) => {206 let mut map = serializer.serialize_map(Some(obj.len()))?;207 for (field, value) in obj.iter(208 #[cfg(feature = "exp-preserve-order")]209 true,210 ) {211 let mut serde_error = None;212 // TODO: rewrite using try{} after stabilization213 in_description_frame(214 || format!("object field {field:?}"),215 || {216 let v = value?;217 if let Err(e) = map.serialize_entry(field.as_str(), &v) {218 serde_error = Some(e);219 }220 Ok(())221 },222 )223 .map_err(|e| S::Error::custom(e.to_string()))?;224 if let Some(e) = serde_error {225 return Err(e);226 }227 }228 map.end()229 }230 Self::Func(_) => Err(S::Error::custom("tried to manifest function")),231 }232 }233}234235struct IntoVecValSerializer {236 variant: Option<IStr>,237 data: Vec<Val>,238}239impl IntoVecValSerializer {240 fn new() -> Self {241 Self {242 variant: None,243 data: Vec::new(),244 }245 }246 fn with_capacity(capacity: usize) -> Self {247 Self {248 variant: None,249 data: Vec::with_capacity(capacity),250 }251 }252 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {253 Self {254 variant: Some(variant.into()),255 data: Vec::with_capacity(capacity),256 }257 }258}259impl SerializeSeq for IntoVecValSerializer {260 type Ok = Val;261 type Error = JrError;262263 fn serialize_element<T>(&mut self, value: &T) -> Result<()>264 where265 T: ?Sized + Serialize,266 {267 let value = value.serialize(IntoValSerializer)?;268 self.data.push(value);269 Ok(())270 }271272 fn end(self) -> Result<Val> {273 let inner = Val::arr(self.data);274 if let Some(variant) = self.variant {275 let mut out = ObjValue::builder_with_capacity(1);276 out.field(variant).value(inner);277 Ok(Val::Obj(out.build()))278 } else {279 Ok(inner)280 }281 }282}283impl SerializeTuple for IntoVecValSerializer {284 type Ok = Val;285 type Error = JrError;286287 fn serialize_element<T>(&mut self, value: &T) -> Result<()>288 where289 T: ?Sized + Serialize,290 {291 SerializeSeq::serialize_element(self, value)292 }293294 fn end(self) -> Result<Val> {295 SerializeSeq::end(self)296 }297}298impl SerializeTupleVariant for IntoVecValSerializer {299 type Ok = Val;300 type Error = JrError;301302 fn serialize_field<T>(&mut self, value: &T) -> Result<()>303 where304 T: ?Sized + Serialize,305 {306 SerializeSeq::serialize_element(self, value)307 }308309 fn end(self) -> Result<Val> {310 SerializeSeq::end(self)311 }312}313impl SerializeTupleStruct for IntoVecValSerializer {314 type Ok = Val;315 type Error = JrError;316317 fn serialize_field<T>(&mut self, value: &T) -> Result<()>318 where319 T: ?Sized + Serialize,320 {321 SerializeSeq::serialize_element(self, value)322 }323324 fn end(self) -> Result<Val> {325 SerializeSeq::end(self)326 }327}328329struct IntoObjValueSerializer {330 variant: Option<IStr>,331 data: ObjValueBuilder,332 key: Option<IStr>,333}334impl IntoObjValueSerializer {335 fn new() -> Self {336 Self {337 variant: None,338 data: ObjValue::builder(),339 key: None,340 }341 }342 fn with_capacity(capacity: usize) -> Self {343 Self {344 variant: None,345 data: ObjValue::builder_with_capacity(capacity),346 key: None,347 }348 }349 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {350 Self {351 variant: Some(variant.into()),352 data: ObjValue::builder_with_capacity(capacity),353 key: None,354 }355 }356}357impl SerializeMap for IntoObjValueSerializer {358 type Ok = Val;359 type Error = JrError;360361 fn serialize_key<T>(&mut self, key: &T) -> Result<()>362 where363 T: ?Sized + Serialize,364 {365 let key = key.serialize(IntoValSerializer)?;366 let key = key.to_string()?;367 self.key = Some(key);368 Ok(())369 }370371 fn serialize_value<T>(&mut self, value: &T) -> Result<()>372 where373 T: ?Sized + Serialize,374 {375 let key = self.key.take().expect("no serialize_key called");376 let value = value.serialize(IntoValSerializer)?;377 self.data.field(key).try_value(value)?;378 Ok(())379 }380381 // TODO: serialize_key/serialize_value382 fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>383 where384 K: ?Sized + Serialize,385 V: ?Sized + Serialize,386 {387 let key = key.serialize(IntoValSerializer)?;388 let key = key.to_string()?;389 let value = value.serialize(IntoValSerializer)?;390 self.data.field(key).try_value(value)?;391 Ok(())392 }393394 fn end(self) -> Result<Val> {395 let inner = Val::Obj(self.data.build());396 if let Some(variant) = self.variant {397 let mut out = ObjValue::builder_with_capacity(1);398 out.field(variant).value(inner);399 Ok(Val::Obj(out.build()))400 } else {401 Ok(inner)402 }403 }404}405impl SerializeStruct for IntoObjValueSerializer {406 type Ok = Val;407 type Error = JrError;408409 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>410 where411 T: ?Sized + Serialize,412 {413 SerializeMap::serialize_entry(self, key, value)?;414 Ok(())415 }416417 fn end(self) -> Result<Val> {418 SerializeMap::end(self)419 }420}421impl SerializeStructVariant for IntoObjValueSerializer {422 type Ok = Val;423424 type Error = JrError;425426 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>427 where428 T: ?Sized + Serialize,429 {430 SerializeMap::serialize_entry(self, key, value)?;431 Ok(())432 }433434 fn end(self) -> Result<Val> {435 SerializeMap::end(self)436 }437}438439struct IntoValSerializer;440impl Serializer for IntoValSerializer {441 type Ok = Val;442443 type Error = JrError;444445 type SerializeSeq = IntoVecValSerializer;446447 type SerializeTuple = IntoVecValSerializer;448449 type SerializeTupleStruct = IntoVecValSerializer;450451 type SerializeTupleVariant = IntoVecValSerializer;452453 type SerializeMap = IntoObjValueSerializer;454455 type SerializeStruct = IntoObjValueSerializer;456457 type SerializeStructVariant = IntoObjValueSerializer;458459 fn serialize_bool(self, v: bool) -> Result<Val> {460 Ok(Val::Bool(v))461 }462463 fn serialize_i8(self, v: i8) -> Result<Val> {464 Ok(Val::Num(v.into()))465 }466467 fn serialize_i16(self, v: i16) -> Result<Val> {468 Ok(Val::Num(v.into()))469 }470471 fn serialize_i32(self, v: i32) -> Result<Val> {472 Ok(Val::Num(v.into()))473 }474475 fn serialize_i64(self, v: i64) -> Result<Val> {476 Ok(Val::Str(v.to_string().into()))477 }478479 fn serialize_u8(self, v: u8) -> Result<Val> {480 Ok(Val::Num(v.into()))481 }482483 fn serialize_u16(self, v: u16) -> Result<Val> {484 Ok(Val::Num(v.into()))485 }486487 fn serialize_u32(self, v: u32) -> Result<Val> {488 Ok(Val::Num(v.into()))489 }490491 fn serialize_u64(self, v: u64) -> Result<Val> {492 Ok(Val::Str(v.to_string().into()))493 }494495 fn serialize_f32(self, v: f32) -> Result<Val> {496 Ok(Val::try_num(f64::from(v))?)497 }498499 fn serialize_f64(self, v: f64) -> Result<Val> {500 Ok(Val::try_num(v)?)501 }502503 fn serialize_char(self, v: char) -> Result<Val> {504 Ok(Val::Str(v.to_string().into()))505 }506507 fn serialize_str(self, v: &str) -> Result<Val> {508 Ok(Val::Str(v.into()))509 }510511 fn serialize_bytes(self, v: &[u8]) -> Result<Val> {512 Ok(Val::arr(IBytes::from(v)))513 }514515 fn serialize_none(self) -> Result<Val> {516 Ok(Val::Null)517 }518519 fn serialize_some<T>(self, value: &T) -> Result<Val>520 where521 T: ?Sized + Serialize,522 {523 value.serialize(self)524 }525526 fn serialize_unit(self) -> Result<Val> {527 Ok(Val::Null)528 }529530 fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {531 Ok(Val::Null)532 }533534 fn serialize_unit_variant(535 self,536 _name: &'static str,537 _variant_index: u32,538 variant: &'static str,539 ) -> Result<Val> {540 Ok(Val::Str(variant.into()))541 }542543 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Val>544 where545 T: ?Sized + Serialize,546 {547 value.serialize(self)548 }549550 fn serialize_newtype_variant<T>(551 self,552 _name: &'static str,553 _variant_index: u32,554 variant: &'static str,555 value: &T,556 ) -> Result<Val>557 where558 T: ?Sized + Serialize,559 {560 let mut out = ObjValue::builder_with_capacity(1);561 let value = value.serialize(self)?;562 out.field(variant).value(value);563 Ok(Val::Obj(out.build()))564 }565566 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {567 Ok(len.map_or_else(568 IntoVecValSerializer::new,569 IntoVecValSerializer::with_capacity,570 ))571 }572573 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {574 Ok(IntoVecValSerializer::with_capacity(len))575 }576577 fn serialize_tuple_struct(578 self,579 _name: &'static str,580 len: usize,581 ) -> Result<Self::SerializeTupleStruct, Self::Error> {582 Ok(IntoVecValSerializer::with_capacity(len))583 }584585 fn serialize_tuple_variant(586 self,587 _name: &'static str,588 _variant_index: u32,589 variant: &'static str,590 len: usize,591 ) -> Result<Self::SerializeTupleVariant, Self::Error> {592 Ok(IntoVecValSerializer::variant_with_capacity(variant, len))593 }594595 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {596 Ok(len.map_or_else(597 IntoObjValueSerializer::new,598 IntoObjValueSerializer::with_capacity,599 ))600 }601602 fn serialize_struct(603 self,604 _name: &'static str,605 len: usize,606 ) -> Result<Self::SerializeStruct, Self::Error> {607 Ok(IntoObjValueSerializer::with_capacity(len))608 }609610 fn serialize_struct_variant(611 self,612 _name: &'static str,613 _variant_index: u32,614 variant: &'static str,615 len: usize,616 ) -> Result<Self::SerializeStructVariant, Self::Error> {617 Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))618 }619}620621impl Val {622 pub fn from_serde(v: impl Serialize) -> Result<Self, JrError> {623 v.serialize(IntoValSerializer)624 }625}626627impl serde::ser::Error for JrError {628 fn custom<T>(msg: T) -> Self629 where630 T: std::fmt::Display,631 {632 runtime_error!("serde: {msg}")633 }634}crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -42,6 +42,7 @@
use jrsonnet_gcmodule::{Cc, Trace, cc_dyn};
pub use jrsonnet_interner::{IBytes, IStr};
pub use jrsonnet_ir as parser;
+pub use jrsonnet_ir::NumValue;
use jrsonnet_ir::{Expr, Source, SourcePath};
#[doc(hidden)]
pub use jrsonnet_macros;
crates/jrsonnet-evaluator/src/stdlib/format.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -829,7 +829,7 @@
#[cfg(test)]
pub mod test_format {
use super::*;
- use crate::val::NumValue;
+ use crate::NumValue;
#[test]
fn parse() {
crates/jrsonnet-evaluator/src/typed/conversions.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -2,6 +2,8 @@
use jrsonnet_gcmodule::Trace;
use jrsonnet_interner::{IBytes, IStr};
+use jrsonnet_ir::NumValue;
+pub use jrsonnet_ir::{MAX_SAFE_INTEGER, MIN_SAFE_INTEGER};
use jrsonnet_types::{ComplexValType, ValType};
use crate::{
@@ -10,7 +12,7 @@
bail,
function::FuncVal,
typed::CheckType,
- val::{IndexableVal, NumValue, StrValue, ThunkMapper},
+ val::{IndexableVal, StrValue, ThunkMapper},
};
#[doc(hidden)]
@@ -219,11 +221,6 @@
Ok(inner.map(<ThunkFromUntyped<T>>::default()))
}
}
-
-#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]
-pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;
-#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]
-pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;
macro_rules! impl_int {
($($ty:ty)*) => {$(
crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -5,7 +5,6 @@
marker::PhantomData,
mem::replace,
num::NonZeroU32,
- ops::Deref,
rc::Rc,
};
@@ -14,16 +13,15 @@
pub use jrsonnet_macros::Thunk;
use jrsonnet_types::ValType;
use rustc_hash::FxHashMap;
-use thiserror::Error;
pub use crate::arr::{ArrValue, ArrayLike};
use crate::{
- ObjValue, Result, SupThis, Unbound, WeakSupThis, bail,
+ NumValue, ObjValue, Result, SupThis, Unbound, WeakSupThis, bail,
error::{Error, ErrorKind::*},
function::FuncVal,
gc::WithCapacityExt as _,
manifest::{ManifestFormat, ToStringFormat},
- typed::{BoundedUsize, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER},
+ typed::BoundedUsize,
};
pub trait ThunkValue: Trace {
@@ -439,134 +437,6 @@
let a = self.clone().into_flat();
let b = other.clone().into_flat();
a.cmp(&b)
- }
-}
-
-/// Represents jsonnet number
-/// Jsonnet numbers are finite f64, with NaNs disallowed
-#[derive(Trace, Clone, Copy)]
-#[repr(transparent)]
-pub struct NumValue(f64);
-impl NumValue {
- /// Creates a [`NumValue`], if value is finite and not NaN
- pub fn new(v: f64) -> Option<Self> {
- if !v.is_finite() {
- return None;
- }
- Some(Self(v))
- }
- #[inline]
- pub const fn get(&self) -> f64 {
- self.0
- }
- pub(crate) fn truncate_for_bitwise(self) -> Result<i64> {
- if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {
- bail!("numberic value outside of safe integer range for bitwise operation");
- }
- #[expect(clippy::cast_possible_truncation, reason = "intended")]
- Ok(self.0 as i64)
- }
-}
-impl PartialEq for NumValue {
- fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
- }
-}
-impl Eq for NumValue {}
-impl Ord for NumValue {
- #[inline]
- fn cmp(&self, other: &Self) -> Ordering {
- // Can't use `total_cmp`: its behavior for `-0` and `0`
- // is not following wanted.
- unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }
- }
-}
-impl PartialOrd for NumValue {
- #[inline]
- fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
- Some(self.cmp(other))
- }
-}
-impl Debug for NumValue {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- Debug::fmt(&self.0, f)
- }
-}
-impl Display for NumValue {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- Display::fmt(&self.0, f)
- }
-}
-impl Deref for NumValue {
- type Target = f64;
-
- #[inline]
- fn deref(&self) -> &Self::Target {
- &self.0
- }
-}
-macro_rules! impl_num {
- ($($ty:ty),+) => {$(
- impl From<$ty> for NumValue {
- #[inline]
- fn from(value: $ty) -> Self {
- Self(value.into())
- }
- }
- )+};
-}
-impl_num!(i8, u8, i16, u16, i32, u32);
-
-#[derive(Clone, Copy, Debug, Error, Trace)]
-pub enum ConvertNumValueError {
- #[error("overflow")]
- Overflow,
- #[error("underflow")]
- Underflow,
- #[error("non-finite")]
- NonFinite,
-}
-impl From<ConvertNumValueError> for Error {
- fn from(e: ConvertNumValueError) -> Self {
- Self::new(e.into())
- }
-}
-
-macro_rules! impl_try_num {
- ($($ty:ty),+) => {$(
- impl TryFrom<$ty> for NumValue {
- type Error = ConvertNumValueError;
- #[inline]
- fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {
- #[expect(clippy::cast_precision_loss, reason = "precision loss is explicitly handled")]
- let value = value as f64;
- if value < MIN_SAFE_INTEGER {
- return Err(ConvertNumValueError::Underflow)
- } else if value > MAX_SAFE_INTEGER {
- return Err(ConvertNumValueError::Overflow)
- }
- // Number is finite.
- Ok(Self(value))
- }
- }
- )+};
-}
-impl_try_num!(usize, isize, i64, u64);
-
-impl TryFrom<f64> for NumValue {
- type Error = ConvertNumValueError;
-
- #[inline]
- fn try_from(value: f64) -> Result<Self, Self::Error> {
- Self::new(value).ok_or(ConvertNumValueError::NonFinite)
- }
-}
-impl TryFrom<f32> for NumValue {
- type Error = ConvertNumValueError;
-
- #[inline]
- fn try_from(value: f32) -> Result<Self, Self::Error> {
- Self::new(f64::from(value)).ok_or(ConvertNumValueError::NonFinite)
}
}
crates/jrsonnet-ir-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir-parser/src/lib.rs
+++ b/crates/jrsonnet-ir-parser/src/lib.rs
@@ -4,8 +4,8 @@
use jrsonnet_ir::{
ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,
ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,
- ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,
- Source, Span, Spanned, UnaryOpType, Visibility, unescape,
+ ImportKind, IndexPart, LiteralType, Member, NumValue, ObjBody, ObjComp, ObjMembers, Slice,
+ SliceDesc, Source, Span, Spanned, UnaryOpType, Visibility, unescape,
};
use jrsonnet_lexer::{Lexeme, Lexer, Span as LexSpan, SyntaxKind, T, collect_lexed_str_block};
@@ -202,17 +202,21 @@
)
}
-fn parse_number(p: &mut Parser<'_>) -> Result<f64> {
+fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {
let text = p.text();
let n: f64 = text
.replace('_', "")
.parse()
.map_err(|_| p.error(format!("invalid number literal: {text}")))?;
- if !n.is_finite() {
- return Err(p.error("numbers are finite".into()));
- }
+
+ let v = match NumValue::try_from(n) {
+ Ok(v) => v,
+ Err(e) => return Err(p.error(format!("invalid number value: {e}"))),
+ };
+
p.eat_any();
- Ok(n)
+
+ Ok(v)
}
fn ident(p: &mut Parser<'_>) -> Result<IStr> {
crates/jrsonnet-ir/Cargo.tomldiffbeforeafterboth--- a/crates/jrsonnet-ir/Cargo.toml
+++ b/crates/jrsonnet-ir/Cargo.toml
@@ -19,6 +19,7 @@
static_assertions.workspace = true
peg.workspace = true
+thiserror.workspace = true
[dev-dependencies]
insta.workspace = true
crates/jrsonnet-ir/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir/src/expr.rs
+++ b/crates/jrsonnet-ir/src/expr.rs
@@ -8,6 +8,7 @@
use jrsonnet_interner::IStr;
use crate::{
+ NumValue,
function::{FunctionSignature, ParamDefault, ParamName, ParamParse},
source::Source,
};
@@ -398,7 +399,7 @@
/// String value: "hello"
Str(IStr),
/// Number: 1, 2.0, 2e+20
- Num(f64),
+ Num(NumValue),
/// Variable name: test
Var(Spanned<IStr>),
crates/jrsonnet-ir/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir/src/lib.rs
+++ b/crates/jrsonnet-ir/src/lib.rs
@@ -1,7 +1,10 @@
#![allow(clippy::redundant_closure_call, clippy::derive_partial_eq_without_eq)]
mod expr;
+use std::{cmp::Ordering, fmt, ops::Deref};
+
pub use expr::*;
+use jrsonnet_gcmodule::Acyclic;
pub use jrsonnet_interner::IStr;
pub mod function;
mod location;
@@ -14,3 +17,134 @@
Source, SourceDefaultIgnoreJpath, SourceDirectory, SourceFifo, SourceFile, SourcePath,
SourcePathT, SourceVirtual,
};
+
+// It seels to be a wrong place for this kind of stuff, but as it would also be used for static analysis and
+// is already wanted for NumValue, I don't know a better place.
+#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]
+pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;
+#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]
+pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;
+
+/// Represents jsonnet number
+/// Jsonnet numbers are finite f64, with NaNs disallowed
+#[derive(Acyclic, Clone, Copy)]
+pub struct NumValue(f64);
+impl NumValue {
+ /// Creates a [`NumValue`], if value is finite and not NaN
+ pub fn new(v: f64) -> Option<Self> {
+ if !v.is_finite() {
+ return None;
+ }
+ Some(Self(v))
+ }
+ #[inline]
+ pub const fn get(&self) -> f64 {
+ self.0
+ }
+ pub fn truncate_for_bitwise(self) -> Result<i64, ConvertNumValueError> {
+ if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER {
+ return Err(ConvertNumValueError::BitwiseSafeRange);
+ }
+ #[expect(clippy::cast_possible_truncation, reason = "intended")]
+ Ok(self.0 as i64)
+ }
+}
+impl PartialEq for NumValue {
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+}
+impl Eq for NumValue {}
+impl Ord for NumValue {
+ #[inline]
+ fn cmp(&self, other: &Self) -> Ordering {
+ // Can't use `total_cmp`: its behavior for `-0` and `0`
+ // is not following wanted.
+ unsafe { self.0.partial_cmp(&other.0).unwrap_unchecked() }
+ }
+}
+impl PartialOrd for NumValue {
+ #[inline]
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+impl fmt::Debug for NumValue {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Debug::fmt(&self.0, f)
+ }
+}
+impl fmt::Display for NumValue {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Display::fmt(&self.0, f)
+ }
+}
+impl Deref for NumValue {
+ type Target = f64;
+
+ #[inline]
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+macro_rules! impl_num {
+ ($($ty:ty),+) => {$(
+ impl From<$ty> for NumValue {
+ #[inline]
+ fn from(value: $ty) -> Self {
+ Self(value.into())
+ }
+ }
+ )+};
+}
+impl_num!(i8, u8, i16, u16, i32, u32);
+
+#[derive(Clone, Copy, Debug, thiserror::Error, Acyclic)]
+pub enum ConvertNumValueError {
+ #[error("overflow")]
+ Overflow,
+ #[error("underflow")]
+ Underflow,
+ #[error("non-finite")]
+ NonFinite,
+ #[error("float out of safe int range")]
+ BitwiseSafeRange,
+}
+
+macro_rules! impl_try_num {
+ ($($ty:ty),+) => {$(
+ impl TryFrom<$ty> for NumValue {
+ type Error = ConvertNumValueError;
+ #[inline]
+ fn try_from(value: $ty) -> Result<Self, ConvertNumValueError> {
+ #[expect(clippy::cast_precision_loss, reason = "precision loss is explicitly handled")]
+ let value = value as f64;
+ if value < MIN_SAFE_INTEGER {
+ return Err(ConvertNumValueError::Underflow)
+ } else if value > MAX_SAFE_INTEGER {
+ return Err(ConvertNumValueError::Overflow)
+ }
+ // Number is finite.
+ Ok(Self(value))
+ }
+ }
+ )+};
+}
+impl_try_num!(usize, isize, i64, u64);
+
+impl TryFrom<f64> for NumValue {
+ type Error = ConvertNumValueError;
+
+ #[inline]
+ fn try_from(value: f64) -> Result<Self, Self::Error> {
+ Self::new(value).ok_or(ConvertNumValueError::NonFinite)
+ }
+}
+impl TryFrom<f32> for NumValue {
+ type Error = ConvertNumValueError;
+
+ #[inline]
+ fn try_from(value: f32) -> Result<Self, Self::Error> {
+ Self::new(f64::from(value)).ok_or(ConvertNumValueError::NonFinite)
+ }
+}
crates/jrsonnet-peg-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -4,8 +4,8 @@
use jrsonnet_ir::{
ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BindSpec, CompSpec, Destruct, DestructRest, Expr,
ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,
- ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,
- Source, Span, Spanned, Visibility, unescape,
+ ImportKind, IndexPart, LiteralType, Member, NumValue, ObjBody, ObjComp, ObjMembers, Slice,
+ SliceDesc, Source, Span, Spanned, Visibility, unescape,
};
use peg::parser;
@@ -52,7 +52,7 @@
/// Sequence of digits
rule uint_str() -> &'input str = a:$(digit()+ ("_" digit()+)*) { a }
/// Number in scientific notation format
- rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.replace("_","").parse().map_err(|_| "<number>") }} / expected!("<number>")
+ rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.replace('_',"").parse().map_err(|_| "<number>") }} / expected!("<number>")
/// Reserved word followed by any non-alphanumberic
rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()
@@ -267,7 +267,7 @@
Expr::ArrComp(Rc::new(expr), specs)
}
pub rule number_expr(s: &ParserSettings) -> Expr
- = n:number() {? if n.is_finite() {
+ = n:number() {? if let Some(n) = NumValue::new(n) {
Ok(Expr::Num(n))
} else {
Err("!!!numbers are finite")
crates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -12,13 +12,12 @@
pub use encoding::*;
pub use hash::*;
use jrsonnet_evaluator::{
- ContextBuilder, IStr, ObjValue, ObjValueBuilder, Thunk, Val,
+ ContextBuilder, IStr, NumValue, ObjValue, ObjValueBuilder, Thunk, Val,
error::Result,
function::{CallLocation, FuncVal, builtin_id},
tla::TlaArg,
trace::PathResolver,
typed::SerializeTypedObj as _,
- val::NumValue,
};
use jrsonnet_gcmodule::{Acyclic, Cc, Trace};
use jrsonnet_ir::Source;
crates/jrsonnet-stdlib/src/operator.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/operator.rs
+++ b/crates/jrsonnet-stdlib/src/operator.rs
@@ -2,12 +2,12 @@
//! However, in our case we instead implement them in native, and implement native functions on top of core for backwards compatibility
use jrsonnet_evaluator::{
- IStr, Result, Val,
+ IStr, NumValue, Result, Val,
function::builtin,
operator::evaluate_mod_op,
stdlib::std_format,
typed::{Either, Either2},
- val::{NumValue, equals, primitive_equals},
+ val::{equals, primitive_equals},
};
#[builtin]