git.delta.rocks / jrsonnet / refs/commits / 36af281ff0ca

--- a/crates/jrsonnet-evaluator/src/analyze.rs
+++ b/crates/jrsonnet-evaluator/src/analyze.rs
@@ -1959,48 +1959,6 @@
 	}
 }
 
-#[cfg(test)]
-fn render_diagnostics(src: &str, diags: &[Diagnostic]) -> String {
-	use std::fmt::Write;
-
-	use hi_doc::{Formatting, SnippetBuilder, Text};
-
-	let mut out = String::new();
-	let mut unspanned = Vec::new();
-	let mut spanned: Vec<&Diagnostic> = Vec::new();
-	for d in diags {
-		if d.span.is_some() {
-			spanned.push(d);
-		} else {
-			unspanned.push(d);
-		}
-	}
-	if !spanned.is_empty() {
-		let mut builder = SnippetBuilder::new(src);
-		for d in spanned {
-			let span = d.span.as_ref().expect("spanned");
-			let ab = match d.level {
-				DiagLevel::Error => {
-					builder.error(Text::fragment(d.message.clone(), Formatting::default()))
-				}
-				DiagLevel::Warning => {
-					builder.warning(Text::fragment(d.message.clone(), Formatting::default()))
-				}
-			};
-			ab.range(span.range()).build();
-		}
-		out.push_str(&hi_doc::source_to_ansi(&builder.build()));
-	}
-	for d in unspanned {
-		let prefix = match d.level {
-			DiagLevel::Error => "error",
-			DiagLevel::Warning => "warning",
-		};
-		writeln!(out, "{prefix}: {}", d.message).expect("fmt");
-	}
-	out
-}
-
 pub struct AnalysisReport {
 	pub lir: LExpr,
 	pub root_shape: ClosureShape,
@@ -2011,16 +1969,63 @@
 
 #[cfg(test)]
 mod tests {
-	use std::fs;
+	#[test]
+	#[cfg(not(feature = "exp-null-coaelse"))]
+	fn snapshots() {
+		use std::fs;
 
-	use insta::{assert_snapshot, glob};
-	use jrsonnet_ir::Source;
+		use insta::{assert_snapshot, glob};
+		use jrsonnet_ir::Source;
 
-	use super::*;
+		use super::*;
 
-	#[test]
-	#[cfg(not(feature = "exp-null-coaelse"))]
-	fn snapshots() {
+		fn render_diagnostics(src: &str, diags: &[Diagnostic]) -> String {
+			use std::fmt::Write;
+
+			use hi_doc::{Formatting, SnippetBuilder, Text};
+
+			let mut out = String::new();
+			let mut unspanned = Vec::new();
+			let mut spanned: Vec<&Diagnostic> = Vec::new();
+			for d in diags {
+				if d.span.is_some() {
+					spanned.push(d);
+				} else {
+					unspanned.push(d);
+				}
+			}
+			if !spanned.is_empty() {
+				let mut builder = SnippetBuilder::new(src);
+				for d in spanned {
+					let span = d.span.as_ref().expect("spanned");
+					let ab = match d.level {
+						DiagLevel::Error => {
+							builder.error(Text::fragment(d.message.clone(), Formatting::default()))
+						}
+						DiagLevel::Warning => builder
+							.warning(Text::fragment(d.message.clone(), Formatting::default())),
+					};
+					ab.range(span.range()).build();
+				}
+				out.push_str(&hi_doc::source_to_ansi(&builder.build()));
+			}
+			for d in unspanned {
+				let prefix = match d.level {
+					DiagLevel::Error => "error",
+					DiagLevel::Warning => "warning",
+				};
+				writeln!(out, "{prefix}: {}", d.message).expect("fmt");
+			}
+			out
+		}
+		fn fmt_depth(d: u32) -> String {
+			if d == u32::MAX {
+				"none".into()
+			} else {
+				d.to_string()
+			}
+		}
+
 		glob!("analysis_tests/*.jsonnet", |path| {
 			let code = fs::read_to_string(path).expect("read test file");
 			let src = Source::new_virtual("<test>".into(), code.clone().into());
@@ -2041,13 +2046,5 @@
 			);
 			assert_snapshot!(rendered);
 		});
-	}
-
-	fn fmt_depth(d: u32) -> String {
-		if d == u32::MAX {
-			"none".into()
-		} else {
-			d.to_string()
-		}
 	}
 }

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -123,9 +123,9 @@
 	EagerCompspecCaptured,
 
 	#[error("array out of bounds: {0} is not within [0,{1})")]
-	ArrayBoundsError(isize, u32),
+	ArrayBoundsError(f64, u32),
 	#[error("string out of bounds: {0} is not within [0,{1})")]
-	StringBoundsError(usize, usize),
+	StringBoundsError(f64, u32),
 
 	#[error("assert failed: {}", format_empty_str(.0))]
 	AssertionFailed(IStr),

18		LIndexPart, LObjAsserts, LObjBody, LObjMembers, LSlot,18		LIndexPart, LObjAsserts, LObjBody, LObjMembers, LSlot,
19	},19	},
20	arr::ArrValue,20	arr::ArrValue,
21	bail, error,21	bail,
22	error::{ErrorKind::*, suggest_object_fields},22	error::{ErrorKind::*, suggest_object_fields},
23	evaluate::{destructure::fill_letrec_binds, operator::evaluate_unary_op},23	evaluate::{destructure::fill_letrec_binds, operator::evaluate_unary_op},
24	function::{CallLocation, FuncDesc, FuncVal, prepared::PreparedFuncVal},24	function::{CallLocation, FuncDesc, FuncVal, prepared::PreparedFuncVal},
25	in_frame,25	in_frame,
26	typed::FromUntyped as _,26	typed::{BoundedUsize, FromUntyped as _},
27	val::{CachedUnbound, Thunk},27	val::{CachedUnbound, Thunk},
28	with_state,28	with_state,
29};29};
193		}193		}
194		LExpr::ArrComp(comp) => evaluate_arr_comp(ctx, comp)?,194		LExpr::ArrComp(comp) => evaluate_arr_comp(ctx, comp)?,
195		LExpr::Slice(slice) => {195		LExpr::Slice(slice) => {
196			use crate::typed::BoundedUsize;
197			let val = evaluate(ctx.clone(), &slice.value)?;196			let val = evaluate(ctx.clone(), &slice.value)?;
198			let indexable = val.into_indexable()?;197			let indexable = val.into_indexable()?;
199			let start = slice198			let start = slice
200				.start199				.start
201				.as_ref()200				.as_ref()
202				.map(|e| evaluate(ctx.clone(), e))201				.map(|e| evaluate(ctx.clone(), e))
203				.transpose()?202				.transpose()?
204				.map(|v| -> Result<i32> {203				.map(|v| -> Result<i32> { i32::from_untyped(v).description("slice start value") })
205					v.as_num()
206						.ok_or_else(|| {
207							TypeMismatch("slice start", vec![ValType::Num], v.value_type()).into()
208						})
209						.map(|n| n as i32)
210				})
211				.transpose()?;204				.transpose()?;
212			let end = slice205			let end = slice
213				.end206				.end
214				.as_ref()207				.as_ref()
215				.map(|e| evaluate(ctx.clone(), e))208				.map(|e| evaluate(ctx.clone(), e))
216				.transpose()?209				.transpose()?
217				.map(|v| -> Result<i32> {210				.map(|v| -> Result<i32> { i32::from_untyped(v).description("slice end value") })
218					v.as_num()
219						.ok_or_else(|| {
220							TypeMismatch("slice end", vec![ValType::Num], v.value_type()).into()
221						})
222						.map(|n| n as i32)
223				})
224				.transpose()?;211				.transpose()?;
225			let step = slice212			let step = slice
228				.map(|e| evaluate(ctx, e))215				.map(|e| evaluate(ctx, e))
229				.transpose()?216				.transpose()?
230				.map(|v| -> Result<BoundedUsize<1, { i32::MAX as usize }>> {217				.map(|v| -> Result<BoundedUsize<1, { i32::MAX as usize }>> {
231					let n = v.as_num().ok_or_else(|| -> crate::Error {
232						TypeMismatch("slice step", vec![ValType::Num], v.value_type()).into()
233					})?;
234					BoundedUsize::new(n as usize).ok_or_else(|| error!("slice step must be >= 1"))218					BoundedUsize::from_untyped(v).description("slice step value")
235				})219				})
236				.transpose()?;220				.transpose()?;
237			Val::from(indexable.slice(start, end, step)?)221			Val::from(indexable.slice(start, end, step)?)
410				if n.fract() > f64::EPSILON {394				if n.fract() > f64::EPSILON {
411					bail!(FractionalIndex)395					bail!(FractionalIndex)
412				}396				}
397				let len = arr.len();
413				if n < 0.0 {398				if n < 0.0 || n > f64::from(len) {
414					bail!(ArrayBoundsError(399					bail!(ArrayBoundsError(n, len));
415						n as isize, // truncation is fine for error display
416						arr.len()
417					));
418				}400				}
419				#[expect(401				#[expect(
424				let i = n as u32;406				let i = n as u32;
425				arr.get(i)407				arr.get(i)
426					.with_description_src(loc, || format!("element <{i}> access"))?408					.with_description_src(loc, || format!("element <{i}> access"))?
427					.ok_or_else(|| ArrayBoundsError(i as isize, arr.len()))?409					.ok_or_else(|| ArrayBoundsError(n, len))?
428			}410			}
429			(Val::Str(s), Val::Num(idx)) => {411			(Val::Str(s), Val::Num(idx)) => {
430				let n = idx.get();412				let n = idx.get();
431				if n.fract() > f64::EPSILON {413				if n.fract() > f64::EPSILON {
432					bail!(FractionalIndex)414					bail!(FractionalIndex)
433				}415				}
434				let flat = s.clone().into_flat();
435				if n < 0.0 {
436					bail!(ArrayBoundsError(
437						n as isize, // truncation is fine for error display
438						flat.chars().count() as u32
439					));
440				}
441				#[expect(416				#[expect(
442					clippy::cast_possible_truncation,417					clippy::cast_possible_truncation,
443					clippy::cast_sign_loss,418					clippy::cast_sign_loss,
444					reason = "n is checked positive, overflow will truncate as expected"419					reason = "n is checked positive, overflow will truncate as expected"
445				)]420				)]
446				let i = n as usize;421				let i = n as usize;
422				let flat = s.clone().into_flat();
423				#[allow(clippy::cast_possible_truncation, reason = "string is max 4g")]
424				if n >= 0.0
425					&& n <= f64::from(u32::MAX)
447				let Some(char) = flat.chars().nth(i) else {426					&& let Some(char) = flat.chars().nth(i)
427				{
428					Val::string(char)
429				} else {
448					bail!(StringBoundsError(i, flat.chars().count()))430					let len = flat.chars().count();
431					bail!(StringBoundsError(n, len as u32))
449				};432				}
450				Val::string(char)
451			}433			}
452			#[cfg(feature = "exp-null-coaelse")]434			#[cfg(feature = "exp-null-coaelse")]
453			(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),435			(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),
566		let a_ctx = ctx548		let a_ctx = ctx
567			.pack_captures_sup_this(&members.frame_shape)549			.pack_captures_sup_this(&members.frame_shape)
568			.enter(|fill, ctx| {550			.enter(|fill, ctx| {
569				fill_letrec_binds(fill, &ctx, &members.locals);551				fill_letrec_binds(fill, ctx, &members.locals);
570			});552			});
571		for field in &members.fields {553		for field in &members.fields {
572			evaluate_field_member_static(&mut builder, ctx.clone(), a_ctx.clone(), field)?;554			evaluate_field_member_static(&mut builder, ctx.clone(), a_ctx.clone(), field)?;

--- a/crates/jrsonnet-evaluator/src/typed/mod.rs
+++ b/crates/jrsonnet-evaluator/src/typed/mod.rs
@@ -157,9 +157,7 @@
 			Self::BoundedNumber(from, to) => {
 				if let Val::Num(n) = value {
 					let n = n.get();
-					if from.map(|from| from > n).unwrap_or(false)
-						|| to.map(|to| to < n).unwrap_or(false)
-					{
+					if from.is_some_and(|from| from > n) || to.is_some_and(|to| to < n) {
 						return Err(TypeError::BoundsFailed(n, *from, *to).into());
 					}
 					Ok(())

--- a/crates/jrsonnet-interner/src/inner.rs
+++ b/crates/jrsonnet-interner/src/inner.rs
@@ -161,6 +161,12 @@
 		// SAFETY: header is initialized
 		unsafe { (*header).refcnt() }
 	}
+
+	pub fn len32(&self) -> u32 {
+		let header = Self::header(self);
+		// SAFETY: header is initialized
+		unsafe { (*header).size }
+	}
 }
 
 impl Clone for Inner {

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -53,6 +53,10 @@
 	pub fn cast_bytes(self) -> IBytes {
 		IBytes(self.0.clone())
 	}
+
+	pub fn len32(&self) -> u32 {
+		self.0.len32()
+	}
 }
 
 impl Deref for IStr {

--- a/crates/jrsonnet-ir-parser/src/lib.rs
+++ b/crates/jrsonnet-ir-parser/src/lib.rs
@@ -1038,7 +1038,7 @@
 	}
 	let e = expr(&mut p)?;
 	if !p.at_eof() {
-		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));
+		return Err(p.error(format!("expected end of file, got {}", p.current_desc())));
 	}
 	Ok(e)
 }
@@ -1051,10 +1051,7 @@
 
 #[cfg(test)]
 mod tests {
-	use std::fs;
-
-	use insta::{assert_snapshot, glob};
-	use jrsonnet_ir::{IStr, Source};
+	use insta::assert_snapshot;
 
 	use super::*;
 
@@ -1159,6 +1156,11 @@
 	#[test]
 	#[cfg(not(feature = "exp-null-coaelse"))]
 	fn peg_snapshots() {
+		use std::fs;
+
+		use insta::glob;
+		use jrsonnet_ir::{IStr, Source};
+
 		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {
 			let input = fs::read_to_string(path).expect("read test file");
 			let source = Source::new_virtual("<test>".into(), IStr::empty());

--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -433,16 +433,16 @@
 
 #[cfg(test)]
 mod tests {
-	use std::fs;
+	#[test]
+	#[cfg(not(feature = "exp-null-coaelse"))]
+	fn snapshots() {
+		use std::fs;
 
-	use insta::{assert_snapshot, glob};
-	use jrsonnet_ir::{IStr, Source};
+		use insta::{assert_snapshot, glob};
+		use jrsonnet_ir::{IStr, Source};
 
-	use crate::{ParserSettings, parse};
+		use crate::{ParserSettings, parse};
 
-	#[test]
-	#[cfg(not(feature = "exp-null-coaelse"))]
-	fn snapshots() {
 		glob!("tests/*.jsonnet", |path| {
 			let input = fs::read_to_string(path).expect("read test file");
 			let v = parse(

--- a/tests/cpp_test_suite_golden_override/error.array_large_index.jsonnet.golden
+++ b/tests/cpp_test_suite_golden_override/error.array_large_index.jsonnet.golden
@@ -1 +1 @@
-array out of bounds: 4294967295 is not within [0,3)
\ No newline at end of file
+array out of bounds: 18446744073709552000 is not within [0,3)
\ No newline at end of file

--- a/tests/go_testdata_golden_override/string_index_negative.jsonnet.golden
+++ b/tests/go_testdata_golden_override/string_index_negative.jsonnet.golden
@@ -1 +1 @@
-array out of bounds: -1 is not within [0,4)
\ No newline at end of file
+string out of bounds: -1 is not within [0,4)
\ No newline at end of file