git.delta.rocks / jrsonnet / refs/commits / d0b9ff27fd80

138#[derive(Debug, Acyclic)]138#[derive(Debug, Acyclic)]
139pub enum LExpr {139pub enum LExpr {
140	Slot(LSlot),140	Slot(LSlot),
141	Null,
142	Bool(bool),141	Trivial(TrivialVal),
143	Str(IStr),
144	Num(NumValue),
145	Arr {142	Arr {
146		shape: ClosureShape,143		shape: ClosureShape,
147		items: Rc<Vec<LExpr>>,144		items: Rc<Vec<LExpr>>,
148	},145	},
146	ArrConst(Rc<Vec<TrivialVal>>),
149	ArrComp(Box<LArrComp>),147	ArrComp(Box<LArrComp>),
150	Obj(LObjBody),148	Obj(LObjBody),
151	ObjExtend(Box<LExpr>, LObjBody),149	ObjExtend(Box<LExpr>, LObjBody),
1345#[allow(clippy::too_many_lines)]1343#[allow(clippy::too_many_lines)]
1346pub fn analyze(expr: &Expr, stack: &mut AnalysisStack, taint: &mut AnalysisResult) -> LExpr {1344pub fn analyze(expr: &Expr, stack: &mut AnalysisStack, taint: &mut AnalysisResult) -> LExpr {
1347	match expr {1345	match expr {
1348		Expr::Literal(span, l) => match l {1346		Expr::Identity(span, l) => match l {
1349			LiteralType::This => stack.use_this(taint).map_or_else(1347			IdentityKind::This => stack.use_this(taint).map_or_else(
1350				|| {1348				|| {
1351					stack.report_error("`self` used outside of object", Some(span.clone()));1349					stack.report_error("`self` used outside of object", Some(span.clone()));
1352					LExpr::BadLocal("self")1350					LExpr::BadLocal("self")
1353				},1351				},
1354				LExpr::Slot,1352				LExpr::Slot,
1355			),1353			),
1356			LiteralType::Super => {1354			IdentityKind::Super => {
1357				if stack.use_super(taint).is_some() {1355				if stack.use_super(taint).is_some() {
1358					LExpr::Super1356					LExpr::Super
1359				} else {1357				} else {
1360					stack.report_error("`super` used outside of object", Some(span.clone()));1358					stack.report_error("`super` used outside of object", Some(span.clone()));
1361					LExpr::BadLocal("super")1359					LExpr::BadLocal("super")
1362				}1360				}
1363			}1361			}
1364			LiteralType::Dollar => stack.use_dollar(taint).map_or_else(1362			IdentityKind::Dollar => stack.use_dollar(taint).map_or_else(
1365				|| {1363				|| {
1366					stack.report_error("`$` used outside of object", Some(span.clone()));1364					stack.report_error("`$` used outside of object", Some(span.clone()));
1367					LExpr::BadLocal("$")1365					LExpr::BadLocal("$")
1368				},1366				},
1369				LExpr::Slot,1367				LExpr::Slot,
1370			),1368			),
1371			LiteralType::Null => LExpr::Null,
1372			LiteralType::True => LExpr::Bool(true),
1373			LiteralType::False => LExpr::Bool(false),
1374		},1369		},
1375		Expr::Str(s) => LExpr::Str(s.clone()),1370		Expr::Trivial(tv) => LExpr::Trivial(tv.clone()),
1376		Expr::Num(n) => LExpr::Num(*n),
1377		Expr::Var(v) => stack1371		Expr::Var(v) => stack
1378			.use_local(&v.value, v.span.clone(), taint)1372			.use_local(&v.value, v.span.clone(), taint)
1379			.map_or_else(|| LExpr::BadLocal("ref"), LExpr::Slot),1373			.map_or_else(|| LExpr::BadLocal("ref"), LExpr::Slot),
1380		Expr::Arr(a) => {1374		Expr::Arr(a) => {
1375			if a.iter().all(|i| matches!(i, Expr::Trivial(_))) {
1376				let trivials: Vec<_> = a
1377					.iter()
1378					.map(|i| match i {
1379						Expr::Trivial(tv) => tv.clone(),
1380						_ => unreachable!("checked above"),
1381					})
1382					.collect();
1383				return LExpr::ArrConst(Rc::new(trivials));
1384			}
1381			let (shape, items) = stack1385			let (shape, items) = stack.in_using_closure(|stack| {
1382				.in_using_closure(|stack| a.iter().map(|v| analyze(v, stack, taint)).collect());1386				a.iter()
1387					.map(|v| analyze(v, stack, taint))
1388					.collect::<Vec<_>>()
1389			});
1383			LExpr::Arr {1390			LExpr::Arr {
1384				shape,1391				shape,
1385				items: Rc::new(items),1392				items: Rc::new(items),
1412		}1419		}
1413		Expr::LocalExpr(binds, body) => analyze_local_expr(binds, body, stack, taint),1420		Expr::LocalExpr(binds, body) => analyze_local_expr(binds, body, stack, taint),
1414		Expr::Import(kind, path_expr) => {1421		Expr::Import(kind, path_expr) => {
1415			let Expr::Str(path) = &**path_expr else {1422			let Expr::Trivial(TrivialVal::Str(path)) = &**path_expr else {
1416				stack.report_error(1423				stack.report_error(
1417					"import path must be a string literal",1424					"import path must be a string literal",
1418					Some(kind.span.clone()),1425					Some(kind.span.clone()),

--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -8,12 +8,7 @@
 
 use jrsonnet_gcmodule::{Cc, cc_dyn};
 
-use crate::{
-	Context, Result, Thunk, Val,
-	analyze::{ClosureShape, LExpr},
-	function::NativeFn,
-	typed::IntoUntyped,
-};
+use crate::{Context, Result, Thunk, Val, analyze::LExpr, function::NativeFn, typed::IntoUntyped};
 
 mod spec;
 pub use spec::{ArrayLike, *};
@@ -42,8 +37,8 @@
 		Self::new(())
 	}
 
-	pub fn expr(ctx: Context, shape: &ClosureShape, exprs: Rc<Vec<LExpr>>) -> Self {
-		Self::new(ExprArray::new(ctx, shape, exprs))
+	pub fn expr(ctx: Context, exprs: Rc<Vec<LExpr>>) -> Self {
+		Self::new(ExprArray::new(ctx, exprs))
 	}
 
 	pub fn repeated(data: Self, repeats: u32) -> Option<Self> {

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -8,11 +8,12 @@
 
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::{IBytes, IStr};
+use jrsonnet_ir::TrivialVal;
 
 use super::{ArrValue, arridx};
 use crate::{
 	Context, Error, ObjValue, Result, Thunk, Val,
-	analyze::{ClosureShape, LExpr},
+	analyze::LExpr,
 	error::ErrorKind::InfiniteRecursionDetected,
 	evaluate::evaluate,
 	function::NativeFn,
@@ -108,6 +109,18 @@
 	}
 }
 
+impl ArrayCheap for Rc<Vec<TrivialVal>> {
+	fn get(&self, index: u32) -> Option<Val> {
+		self.as_slice()
+			.get(index as usize)
+			.map(|tv| tv.clone().into())
+	}
+
+	fn len(&self) -> u32 {
+		arridx(self.as_slice().len())
+	}
+}
+
 #[derive(Debug, Trace, Clone)]
 enum ArrayThunk {
 	Computed(Val),
@@ -123,9 +136,9 @@
 	cached: Cc<RefCell<Vec<ArrayThunk>>>,
 }
 impl ExprArray {
-	pub fn new(outer: Context, shape: &ClosureShape, src: Rc<Vec<LExpr>>) -> Self {
+	pub fn new(ctx: Context, src: Rc<Vec<LExpr>>) -> Self {
 		Self {
-			ctx: Context::enter_using(&outer, shape),
+			ctx,
 			cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),
 			src,
 		}
@@ -153,9 +166,17 @@
 			unreachable!()
 		};
 
-		let new_value: Val = evaluate(self.ctx.clone(), &self.src[index as usize])?;
-		self.cached.borrow_mut()[index as usize] = ArrayThunk::Computed(new_value.clone());
-		Ok(Some(new_value))
+		let result = evaluate(self.ctx.clone(), &self.src[index as usize]);
+		match result {
+			Ok(new_value) => {
+				self.cached.borrow_mut()[index as usize] = ArrayThunk::Computed(new_value.clone());
+				Ok(Some(new_value))
+			}
+			Err(e) => {
+				self.cached.borrow_mut()[index as usize] = ArrayThunk::Waiting;
+				Err(e)
+			}
+		}
 	}
 	fn get_lazy32(&self, index: u32) -> Option<Thunk<Val>> {
 		#[derive(Trace)]

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -52,15 +52,11 @@
 }
 
 pub fn evaluate_trivial(expr: &LExpr) -> Option<Val> {
-	// TODO: Eager trivial array
-	Some(match expr {
-		LExpr::Str(s) => Val::string(s.clone()),
-		LExpr::Num(n) => Val::Num(*n),
-		LExpr::Bool(false) => Val::Bool(false),
-		LExpr::Bool(true) => Val::Bool(true),
-		LExpr::Null => Val::Null,
-		_ => return None,
-	})
+	if let LExpr::Trivial(tv) = expr {
+		Some(tv.clone().into())
+	} else {
+		None
+	}
 }
 
 pub fn evaluate_method(ctx: Context, name: IStr, func: &Rc<LFunction>) -> Val {
@@ -119,13 +115,24 @@
 pub fn evaluate(mut ctx: Context, mut expr: &LExpr) -> Result<Val> {
 	loop {
 		return Ok(match expr {
-			LExpr::Null => Val::Null,
-			LExpr::Bool(b) => Val::Bool(*b),
-			LExpr::Str(s) => Val::string(s.clone()),
-			LExpr::Num(n) => Val::Num(*n),
+			LExpr::Trivial(tv) => tv.clone().into(),
 			LExpr::Slot(slot) => ctx.slot(*slot).evaluate()?,
 			LExpr::BadLocal(name) => panic!("unresolvable reference: {name}"),
-			LExpr::Arr { shape, items } => Val::Arr(ArrValue::expr(ctx, shape, items.clone())),
+			LExpr::ArrConst(rc) => Val::Arr(ArrValue::new(rc.clone())),
+			LExpr::Arr { shape, items } => {
+				let inner = Context::enter_using(&ctx, shape);
+				'eager: {
+					let mut out: Vec<Val> = Vec::with_capacity(items.len());
+					for item in items.iter() {
+						let Ok(r) = evaluate(inner.clone(), item) else {
+							break 'eager;
+						};
+						out.push(r);
+					}
+					return Ok(Val::Arr(ArrValue::new(out)));
+				}
+				Val::Arr(ArrValue::expr(inner, items.clone()))
+			}
 			LExpr::UnaryOp(op, value) => {
 				let value = evaluate(ctx, value)?;
 				evaluate_unary_op(*op, &value)?

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -10,7 +10,7 @@
 
 use jrsonnet_gcmodule::{Acyclic, Cc, Trace, cc_dyn};
 use jrsonnet_interner::IStr;
-use jrsonnet_ir::BinaryOpType;
+use jrsonnet_ir::{BinaryOpType, TrivialVal};
 pub use jrsonnet_macros::Thunk;
 use jrsonnet_types::ValType;
 use rustc_hash::FxHashMap;
@@ -621,6 +621,16 @@
 		Self::Bool(value)
 	}
 }
+impl From<TrivialVal> for Val {
+	fn from(tv: TrivialVal) -> Self {
+		match tv {
+			TrivialVal::Null => Self::Null,
+			TrivialVal::Bool(b) => Self::Bool(b),
+			TrivialVal::Num(n) => Self::Num(n),
+			TrivialVal::Str(s) => Self::string(s),
+		}
+	}
+}
 
 const fn is_function_like(val: &Val) -> bool {
 	matches!(val, Val::Func(_))