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

1959	}1959	}
1960}1960}
1961
1962#[cfg(test)]
1963fn render_diagnostics(src: &str, diags: &[Diagnostic]) -> String {
1964	use std::fmt::Write;
1965
1966	use hi_doc::{Formatting, SnippetBuilder, Text};
1967
1968	let mut out = String::new();
1969	let mut unspanned = Vec::new();
1970	let mut spanned: Vec<&Diagnostic> = Vec::new();
1971	for d in diags {
1972		if d.span.is_some() {
1973			spanned.push(d);
1974		} else {
1975			unspanned.push(d);
1976		}
1977	}
1978	if !spanned.is_empty() {
1979		let mut builder = SnippetBuilder::new(src);
1980		for d in spanned {
1981			let span = d.span.as_ref().expect("spanned");
1982			let ab = match d.level {
1983				DiagLevel::Error => {
1984					builder.error(Text::fragment(d.message.clone(), Formatting::default()))
1985				}
1986				DiagLevel::Warning => {
1987					builder.warning(Text::fragment(d.message.clone(), Formatting::default()))
1988				}
1989			};
1990			ab.range(span.range()).build();
1991		}
1992		out.push_str(&hi_doc::source_to_ansi(&builder.build()));
1993	}
1994	for d in unspanned {
1995		let prefix = match d.level {
1996			DiagLevel::Error => "error",
1997			DiagLevel::Warning => "warning",
1998		};
1999		writeln!(out, "{prefix}: {}", d.message).expect("fmt");
2000	}
2001	out
2002}
20031961
2004pub struct AnalysisReport {1962pub struct AnalysisReport {
2005	pub lir: LExpr,1963	pub lir: LExpr,
20111969
2012#[cfg(test)]1970#[cfg(test)]
2013mod tests {1971mod tests {
1972	#[test]
1973	#[cfg(not(feature = "exp-null-coaelse"))]
1974	fn snapshots() {
2014	use std::fs;1975		use std::fs;
20151976
2016	use insta::{assert_snapshot, glob};1977		use insta::{assert_snapshot, glob};
2017	use jrsonnet_ir::Source;1978		use jrsonnet_ir::Source;
20181979
2019	use super::*;1980		use super::*;
20201981
2021	#[test]1982		fn render_diagnostics(src: &str, diags: &[Diagnostic]) -> String {
2022	#[cfg(not(feature = "exp-null-coaelse"))]1983			use std::fmt::Write;
1984
1985			use hi_doc::{Formatting, SnippetBuilder, Text};
1986
1987			let mut out = String::new();
1988			let mut unspanned = Vec::new();
1989			let mut spanned: Vec<&Diagnostic> = Vec::new();
1990			for d in diags {
1991				if d.span.is_some() {
1992					spanned.push(d);
1993				} else {
1994					unspanned.push(d);
1995				}
1996			}
1997			if !spanned.is_empty() {
1998				let mut builder = SnippetBuilder::new(src);
1999				for d in spanned {
2000					let span = d.span.as_ref().expect("spanned");
2001					let ab = match d.level {
2002						DiagLevel::Error => {
2003							builder.error(Text::fragment(d.message.clone(), Formatting::default()))
2004						}
2005						DiagLevel::Warning => builder
2006							.warning(Text::fragment(d.message.clone(), Formatting::default())),
2007					};
2008					ab.range(span.range()).build();
2009				}
2010				out.push_str(&hi_doc::source_to_ansi(&builder.build()));
2011			}
2012			for d in unspanned {
2013				let prefix = match d.level {
2014					DiagLevel::Error => "error",
2015					DiagLevel::Warning => "warning",
2016				};
2017				writeln!(out, "{prefix}: {}", d.message).expect("fmt");
2018			}
2019			out
2020		}
2023	fn snapshots() {2021		fn fmt_depth(d: u32) -> String {
2022			if d == u32::MAX {
2023				"none".into()
2024			} else {
2025				d.to_string()
2026			}
2027		}
2028
2024		glob!("analysis_tests/*.jsonnet", |path| {2029		glob!("analysis_tests/*.jsonnet", |path| {
2025			let code = fs::read_to_string(path).expect("read test file");2030			let code = fs::read_to_string(path).expect("read test file");
2041			);2046			);
2042			assert_snapshot!(rendered);2047			assert_snapshot!(rendered);
2043		});2048		});
2044	}2049	}
2045
2046	fn fmt_depth(d: u32) -> String {
2047		if d == u32::MAX {
2048			"none".into()
2049		} else {
2050			d.to_string()
2051		}
2052	}
2053}2050}
20542051

--- 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),

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -18,12 +18,12 @@
 		LIndexPart, LObjAsserts, LObjBody, LObjMembers, LSlot,
 	},
 	arr::ArrValue,
-	bail, error,
+	bail,
 	error::{ErrorKind::*, suggest_object_fields},
 	evaluate::{destructure::fill_letrec_binds, operator::evaluate_unary_op},
 	function::{CallLocation, FuncDesc, FuncVal, prepared::PreparedFuncVal},
 	in_frame,
-	typed::FromUntyped as _,
+	typed::{BoundedUsize, FromUntyped as _},
 	val::{CachedUnbound, Thunk},
 	with_state,
 };
@@ -193,7 +193,6 @@
 		}
 		LExpr::ArrComp(comp) => evaluate_arr_comp(ctx, comp)?,
 		LExpr::Slice(slice) => {
-			use crate::typed::BoundedUsize;
 			let val = evaluate(ctx.clone(), &slice.value)?;
 			let indexable = val.into_indexable()?;
 			let start = slice
@@ -201,26 +200,14 @@
 				.as_ref()
 				.map(|e| evaluate(ctx.clone(), e))
 				.transpose()?
-				.map(|v| -> Result<i32> {
-					v.as_num()
-						.ok_or_else(|| {
-							TypeMismatch("slice start", vec![ValType::Num], v.value_type()).into()
-						})
-						.map(|n| n as i32)
-				})
+				.map(|v| -> Result<i32> { i32::from_untyped(v).description("slice start value") })
 				.transpose()?;
 			let end = slice
 				.end
 				.as_ref()
 				.map(|e| evaluate(ctx.clone(), e))
 				.transpose()?
-				.map(|v| -> Result<i32> {
-					v.as_num()
-						.ok_or_else(|| {
-							TypeMismatch("slice end", vec![ValType::Num], v.value_type()).into()
-						})
-						.map(|n| n as i32)
-				})
+				.map(|v| -> Result<i32> { i32::from_untyped(v).description("slice end value") })
 				.transpose()?;
 			let step = slice
 				.step
@@ -228,10 +215,7 @@
 				.map(|e| evaluate(ctx, e))
 				.transpose()?
 				.map(|v| -> Result<BoundedUsize<1, { i32::MAX as usize }>> {
-					let n = v.as_num().ok_or_else(|| -> crate::Error {
-						TypeMismatch("slice step", vec![ValType::Num], v.value_type()).into()
-					})?;
-					BoundedUsize::new(n as usize).ok_or_else(|| error!("slice step must be >= 1"))
+					BoundedUsize::from_untyped(v).description("slice step value")
 				})
 				.transpose()?;
 			Val::from(indexable.slice(start, end, step)?)
@@ -410,11 +394,9 @@
 				if n.fract() > f64::EPSILON {
 					bail!(FractionalIndex)
 				}
-				if n < 0.0 {
-					bail!(ArrayBoundsError(
-						n as isize, // truncation is fine for error display
-						arr.len()
-					));
+				let len = arr.len();
+				if n < 0.0 || n > f64::from(len) {
+					bail!(ArrayBoundsError(n, len));
 				}
 				#[expect(
 					clippy::cast_possible_truncation,
@@ -424,30 +406,30 @@
 				let i = n as u32;
 				arr.get(i)
 					.with_description_src(loc, || format!("element <{i}> access"))?
-					.ok_or_else(|| ArrayBoundsError(i as isize, arr.len()))?
+					.ok_or_else(|| ArrayBoundsError(n, len))?
 			}
 			(Val::Str(s), Val::Num(idx)) => {
 				let n = idx.get();
 				if n.fract() > f64::EPSILON {
 					bail!(FractionalIndex)
 				}
-				let flat = s.clone().into_flat();
-				if n < 0.0 {
-					bail!(ArrayBoundsError(
-						n as isize, // truncation is fine for error display
-						flat.chars().count() as u32
-					));
-				}
 				#[expect(
 					clippy::cast_possible_truncation,
 					clippy::cast_sign_loss,
 					reason = "n is checked positive, overflow will truncate as expected"
 				)]
 				let i = n as usize;
-				let Some(char) = flat.chars().nth(i) else {
-					bail!(StringBoundsError(i, flat.chars().count()))
-				};
-				Val::string(char)
+				let flat = s.clone().into_flat();
+				#[allow(clippy::cast_possible_truncation, reason = "string is max 4g")]
+				if n >= 0.0
+					&& n <= f64::from(u32::MAX)
+					&& let Some(char) = flat.chars().nth(i)
+				{
+					Val::string(char)
+				} else {
+					let len = flat.chars().count();
+					bail!(StringBoundsError(n, len as u32))
+				}
 			}
 			#[cfg(feature = "exp-null-coaelse")]
 			(Val::Null, _) if part.null_coaelse => return Ok(Val::Null),
@@ -566,7 +548,7 @@
 		let a_ctx = ctx
 			.pack_captures_sup_this(&members.frame_shape)
 			.enter(|fill, ctx| {
-				fill_letrec_binds(fill, &ctx, &members.locals);
+				fill_letrec_binds(fill, ctx, &members.locals);
 			});
 		for field in &members.fields {
 			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