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

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@
 jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre97" }
 jrsonnet-macros = { path = "./crates/jrsonnet-macros", version = "0.5.0-pre97" }
 jrsonnet-ir = { path = "./crates/jrsonnet-ir", version = "0.5.0-pre97" }
+jrsonnet-ir-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }
 jrsonnet-peg-parser = { path = "./crates/jrsonnet-peg-parser", version = "0.5.0-pre97" }
 jrsonnet-rowan-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }
 jrsonnet-interner = { path = "./crates/jrsonnet-interner", version = "0.5.0-pre97" }

--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -7,7 +7,7 @@
 
 use jrsonnet_gcmodule::{cc_dyn, Cc};
 use jrsonnet_interner::IBytes;
-use jrsonnet_ir::{Expr, Spanned};
+use jrsonnet_ir::Expr;
 
 use crate::{function::NativeFn, Context, Result, Thunk, Val};
 

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -3,7 +3,7 @@
 
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::{IBytes, IStr};
-use jrsonnet_ir::{Expr, Spanned};
+use jrsonnet_ir::Expr;
 
 use super::ArrValue;
 use crate::function::NativeFn;

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -290,7 +290,7 @@
 }
 impl<T: Acyclic> ErrorSource for &Spanned<T> {
 	fn to_location(self) -> Option<Span> {
-		Some(self.span())
+		Some(self.span.clone())
 	}
 }
 impl ErrorSource for &Span {

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -49,15 +49,15 @@
 
 pub fn evaluate_trivial(expr: &Expr) -> Option<Val> {
 	fn is_trivial(expr: &Expr) -> bool {
-		match &*expr {
+		match expr {
 			Expr::Str(_)
 			| Expr::Num(_)
 			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,
-			Expr::Arr(a) => a.iter().all(|e| is_trivial(&*e)),
+			Expr::Arr(a) => a.iter().all(is_trivial),
 			_ => false,
 		}
 	}
-	Some(match &*expr {
+	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"))
@@ -71,7 +71,7 @@
 			}
 			Val::Arr(ArrValue::eager(
 				n.iter()
-					.map(|e| evaluate_trivial(&*e))
+					.map(evaluate_trivial)
 					.map(|e| e.expect("checked trivial"))
 					.collect(),
 			))
@@ -89,24 +89,21 @@
 	})))
 }
 
-pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {
-	Ok(match field_name {
+pub fn evaluate_field_name(ctx: Context, field_name: &Spanned<FieldName>) -> Result<Option<IStr>> {
+	Ok(match &field_name.value {
 		FieldName::Fixed(n) => Some(n.clone()),
-		FieldName::Dyn(expr) => {
-			// FIXME: Span
-			let value = evaluate(ctx, expr)?;
-			if matches!(value, Val::Null) {
-				None
-			} else {
-				Some(IStr::from_untyped(value)?)
-			}
-		} //
-		  // 	in_frame(
-		  // 	CallLocation::new(&expr.span()),
-		  // 	|| "evaluating field name".to_string(),
-		  // 	|| {
-		  // 	},
-		  // )?,
+		FieldName::Dyn(expr) => in_frame(
+			CallLocation::new(&field_name.span),
+			|| "evaluating field name".to_string(),
+			|| {
+				let v = evaluate(ctx, expr)?;
+				Ok(if matches!(v, Val::Null) {
+					None
+				} else {
+					Some(IStr::from_untyped(v)?)
+				})
+			},
+		)?,
 	})
 }
 
@@ -117,18 +114,21 @@
 ) -> Result<()> {
 	match specs.first() {
 		None => callback(ctx)?,
-		Some(CompSpec::IfSpec(Spanned(IfSpecData(cond), _))) => {
+		Some(CompSpec::IfSpec(IfSpecData { cond, span: _ })) => {
 			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {
 				evaluate_comp(ctx, &specs[1..], callback)?;
 			}
 		}
-		Some(CompSpec::ForSpec(Spanned(ForSpecData(var, expr), _))) => {
-			match evaluate(ctx.clone(), expr)? {
+		Some(CompSpec::ForSpec(ForSpecData {
+			destruct: into,
+			over,
+		})) => {
+			match evaluate(ctx.clone(), over)? {
 				Val::Arr(list) => {
 					for item in list.iter_lazy() {
 						let fctx = Pending::new();
-						let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
-						destruct(var, item, fctx.clone(), &mut new_bindings)?;
+						let mut new_bindings = FxHashMap::with_capacity(into.binds_len());
+						destruct(into, item, fctx.clone(), &mut new_bindings)?;
 						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
 
 						evaluate_comp(ctx, &specs[1..], callback)?;
@@ -235,8 +235,7 @@
 				.field(name.clone())
 				.with_add(*plus)
 				.with_visibility(*visibility)
-				// FIXME
-				// .with_location(value.span())
+				.with_location(field.name.span.clone())
 				.bindable(UnboundValue {
 					uctx,
 					value: value.clone(),
@@ -361,13 +360,13 @@
 	let value = &assertion.0;
 	let msg = &assertion.1;
 	let assertion_result = in_frame(
-		CallLocation::new(&value.span()),
+		CallLocation::new(&value.span),
 		|| "assertion condition".to_owned(),
 		|| bool::from_untyped(evaluate(ctx.clone(), value)?),
 	)?;
 	if !assertion_result {
 		in_frame(
-			CallLocation::new(&value.span()),
+			CallLocation::new(&value.span),
 			|| "assertion failure".to_owned(),
 			|| {
 				if let Some(msg) = msg {
@@ -389,7 +388,7 @@
 
 pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {
 	use Expr::*;
-	Ok(match &*expr {
+	Ok(match expr {
 		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
 		_ => evaluate(ctx, expr)?,
 	})
@@ -433,7 +432,7 @@
 		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,
 		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
 		Var(name) => in_frame(
-			CallLocation::new(&name.span()),
+			CallLocation::new(&name.span),
 			|| format!("local <{}> access", &**name),
 			|| ctx.binding((**name).clone())?.evaluate(),
 		)?,
@@ -591,13 +590,7 @@
 			&Val::Obj(evaluate_object(ctx, b)?),
 		)?,
 		Apply(value, args, tailstrict) => ensure_sufficient_stack(|| {
-			evaluate_apply(
-				ctx,
-				value,
-				args,
-				CallLocation::new(&args.span()),
-				*tailstrict,
-			)
+			evaluate_apply(ctx, value, args, CallLocation::new(&args.span), *tailstrict)
 		})?,
 		Function(params, body) => {
 			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())
@@ -607,20 +600,16 @@
 			evaluate(ctx, &assert.rest)?
 		}
 		ErrorStmt(s, e) => in_frame(
-			CallLocation::new(&s),
+			CallLocation::new(s),
 			|| "error statement".to_owned(),
 			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
 		)?,
 		IfElse(if_else) => {
-			if
-			// FIXME
-			//in_frame(
-			// CallLocation::new(&if_else.cond.0.span()),
-			// || "if condition".to_owned(),
-			// ||
-			bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?)?
-			// )?
-			{
+			if in_frame(
+				CallLocation::new(&if_else.cond.span),
+				|| "if condition".to_owned(),
+				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.cond)?),
+			)? {
 				evaluate(ctx, &if_else.cond_then)?
 			} else {
 				match &if_else.cond_else {
@@ -637,7 +626,7 @@
 			) -> Result<Option<T>> {
 				if let Some(value) = expr {
 					Ok(in_frame(
-						CallLocation::new(&value.span()),
+						CallLocation::new(&value.span),
 						|| format!("slice {desc}"),
 						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),
 					)?)
@@ -659,11 +648,11 @@
 				bail!("computed imports are not supported")
 			};
 			with_state(|s| {
-				let span = kind.span();
+				let span = &kind.span;
 				let resolved_path = s.resolve_from(span.0.source_path(), path)?;
 				Ok(match &**kind {
 					ImportKind::Normal => in_frame(
-						CallLocation::new(&span),
+						CallLocation::new(span),
 						|| format!("import {:?}", path.clone()),
 						|| s.import_resolved(resolved_path),
 					)?,

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 
-use jrsonnet_ir::{BinaryOpType, Expr, Spanned, UnaryOpType};
+use jrsonnet_ir::{BinaryOpType, Expr, UnaryOpType};
 
 use crate::{
 	arr::ArrValue,

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -3,7 +3,7 @@
 use educe::Educe;
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
-use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
+use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span};
 pub use jrsonnet_macros::builtin;
 
 use self::{

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -42,10 +42,10 @@
 pub use import::*;
 use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};
 pub use jrsonnet_interner::{IBytes, IStr};
+pub use jrsonnet_ir as parser;
+use jrsonnet_ir::{Expr, Source, SourcePath};
 #[doc(hidden)]
 pub use jrsonnet_macros;
-pub use jrsonnet_ir as parser;
-use jrsonnet_ir::{Expr, Source, SourcePath, Spanned};
 use jrsonnet_peg_parser::ParserSettings;
 pub use obj::*;
 pub use rustc_hash;

--- a/crates/jrsonnet-ir/src/expr.rs
+++ b/crates/jrsonnet-ir/src/expr.rs
@@ -42,7 +42,7 @@
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct FieldMember {
-	pub name: FieldName,
+	pub name: Spanned<FieldName>,
 	pub plus: bool,
 	pub params: Option<ExprParams>,
 	pub visibility: Visibility,
@@ -295,15 +295,21 @@
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
-pub struct IfSpecData(pub Expr);
+pub struct IfSpecData {
+	pub span: Span,
+	pub cond: Expr,
+}
 
 #[derive(Debug, PartialEq, Acyclic)]
-pub struct ForSpecData(pub Destruct, pub Expr);
+pub struct ForSpecData {
+	pub destruct: Destruct,
+	pub over: Expr,
+}
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub enum CompSpec {
-	IfSpec(Spanned<IfSpecData>),
-	ForSpec(Spanned<ForSpecData>),
+	IfSpec(IfSpecData),
+	ForSpec(ForSpecData),
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
@@ -462,21 +468,20 @@
 }
 
 #[derive(Clone, PartialEq, Acyclic)]
-pub struct Spanned<T: Acyclic>(pub T, pub Span);
+pub struct Spanned<T: Acyclic> {
+	pub value: T,
+	pub span: Span,
+}
 impl<T: Acyclic> Deref for Spanned<T> {
 	type Target = T;
 	fn deref(&self) -> &Self::Target {
-		&self.0
+		&self.value
 	}
 }
 impl<T: Acyclic> Spanned<T> {
 	#[inline]
-	pub fn new(v: T, s: Span) -> Self {
-		Self(v, s)
-	}
-	#[inline]
-	pub fn span(&self) -> Span {
-		self.1.clone()
+	pub fn new(value: T, span: Span) -> Self {
+		Self { value, span }
 	}
 }
 
@@ -488,7 +493,7 @@
 		} else {
 			write!(f, "{:?}", expr)?;
 		}
-		write!(f, " from {:?}", self.span())?;
+		write!(f, " from {:?}", self.span)?;
 		Ok(())
 	}
 }

--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -181,14 +181,14 @@
 			/ "::" {Visibility::Hidden}
 			/ ":" {Visibility::Normal}
 		pub rule field(s: &ParserSettings) -> FieldMember
-			= name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {FieldMember{
+			= name:spanned(<field_name(s)>, s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {FieldMember{
 				name,
 				plus: plus.is_some(),
 				params: None,
 				visibility,
 				value: Rc::new(value),
 			}}
-			/ name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {FieldMember{
+			/ name:spanned(<field_name(s)>, s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {FieldMember{
 				name,
 				plus: false,
 				params: Some(params),
@@ -239,11 +239,11 @@
 				})
 			}
 		pub rule ifspec(s: &ParserSettings) -> IfSpecData
-			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}
+			= i:spanned(<keyword("if")>, s) _ cond:expr(s) {IfSpecData { span: i.span, cond }}
 		pub rule forspec(s: &ParserSettings) -> ForSpecData
-			= keyword("for") _ id:destruct(s) _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}
+			= keyword("for") _ destruct:destruct(s) _ keyword("in") _ over:expr(s) { ForSpecData { destruct, over } }
 		rule compspec(s: &ParserSettings) -> CompSpec
-			= i:spanned(<ifspec(s)>, s) { CompSpec::IfSpec(i) } / f:spanned(<forspec(s)>, s) {CompSpec::ForSpec(f)}
+			= i:ifspec(s) { CompSpec::IfSpec(i) } / f:forspec(s) {CompSpec::ForSpec(f)}
 		pub rule compspecs(s: &ParserSettings) -> Vec<CompSpec>
 			= specs:compspec(s) ++ _ {?
 				if !matches!(specs[0], CompSpec::ForSpec(_)) {
@@ -319,7 +319,7 @@
 				assert, rest
 			})) }
 
-			/ err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.1, Box::new(expr)) }
+			/ err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.span, Box::new(expr)) }
 
 		rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>
 			= _ e:(e:spanned(<expr(s)>, s) _{e})? {e}
@@ -396,14 +396,14 @@
 			}
 		pub rule index_part(s: &ParserSettings) -> IndexPart
 		= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {
-			span: value.1,
-			value: value.0,
+			span: value.span,
+			value: value.value,
 			#[cfg(feature = "exp-null-coaelse")]
 			null_coaelse: n.is_some(),
 		}}
 		/ n:("?" _ "." _ ensure_null_coaelse())? value:spanned(<"[" _ v:expr(s) _ "]" {v}>, s) {IndexPart {
-			span: value.1,
-			value: value.0,
+			span: value.span,
+			value: value.value,
 			#[cfg(feature = "exp-null-coaelse")]
 			null_coaelse: n.is_some(),
 		}}
@@ -423,140 +423,27 @@
 }
 
 #[cfg(test)]
-pub mod tests {
-	use insta::assert_snapshot;
-	use jrsonnet_ir::{IStr, Source};
-
-	use super::parse;
-	use crate::ParserSettings;
-
-	fn parsep(s: &str) -> String {
-		let v = parse(
-			s,
-			&ParserSettings {
-				source: Source::new_virtual("<test>".into(), IStr::empty()),
-			},
-		)
-		.unwrap();
-		format!("{v:#?}")
-	}
-
-	macro_rules! parse {
-		($s:expr) => {
-			assert_snapshot!(parsep($s));
-		};
-	}
-
-	#[test]
-	fn multiline_string() {
-		parse!("|||\n    Hello world!\n     a\n|||");
-		parse!("|||\n  Hello world!\n   a\n|||");
-		parse!("|||\n\t\tHello world!\n\t\t\ta\n|||");
-		parse!("|||\n   Hello world!\n    a\n |||");
-	}
-
-	#[test]
-	fn slice() {
-		parse!("a[1:]");
-		parse!("a[1::]");
-		parse!("a[:1:]");
-		parse!("a[::1]");
-		parse!("str[:len - 1]");
-	}
-
-	#[test]
-	fn string_escaping() {
-		parse!(r#""Hello, \"world\"!""#);
-		parse!(r#"'Hello \'world\'!'"#);
-		parse!(r#"'\\\\'"#);
-	}
-
-	#[test]
-	fn string_unescaping() {
-		parse!(r#""Hello\nWorld""#);
-	}
-
-	#[test]
-	fn string_verbantim() {
-		parse!(r#"@"Hello\n""World""""#);
-	}
-
-	#[test]
-	fn imports() {
-		parse!("import \"hello\"");
-		parse!("importstr \"garnish.txt\"");
-		parse!("importbin \"garnish.bin\"");
-	}
-
-	#[test]
-	fn empty_object() {
-		parse!("{}");
-	}
+mod tests {
+	use std::fs;
 
-	#[test]
-	fn basic_math() {
-		parse!("2+2*2");
-		parse!("2	+ 	  2	  *	2   	");
-		parse!("2+(2+2*2)");
-		parse!("2//comment\n+//comment\n3/*test*/*/*test*/4");
-	}
+	use insta::{assert_snapshot, glob};
+	use jrsonnet_ir::{IStr, Source};
 
-	#[test]
-	fn suffix() {
-		parse!("std.test");
-		parse!("std(2)");
-		parse!("std.test(2)");
-		parse!("a[b]");
-	}
+	use crate::{parse, ParserSettings};
 
 	#[test]
-	fn array_comp() {
-		parse!("[std.deepJoin(x) for x in arr]");
-	}
-
-	#[test]
-	fn reserved() {
-		parse!("null");
-		parse!("nulla");
-	}
-
-	#[test]
-	fn multiple_args_buf() {
-		parse!("a(b, null_fields)");
-	}
-
-	#[test]
-	fn infix_precedence() {
-		parse!("!a && !b");
-		parse!("!a / !b");
-	}
-
-	#[test]
-	fn double_negation() {
-		parse!("!!a");
-	}
-
-	#[test]
-	fn array_test_error() {
-		parse!("[a for a in b if c for e in f]");
-	}
-
-	#[test]
-	fn missing_newline_between_comment_and_eof() {
-		parse!(
-			"{a:1}
-
-			//+213"
-		);
-	}
-
-	#[test]
-	fn default_param_before_nondefault() {
-		parse!("local x(foo = 'foo', bar) = null; null");
-	}
-
-	#[test]
-	fn add_location_info_to_all_sub_expressions() {
-		parse!("{} { local x = 1, x: x } + {}");
+	fn snapshots() {
+		glob!("tests/*.jsonnet", |path| {
+			let input = fs::read_to_string(path).expect("read test file");
+			let v = parse(
+				&input,
+				&ParserSettings {
+					source: Source::new_virtual("<test>".into(), IStr::empty()),
+				},
+			)
+			.unwrap();
+			let v = format!("{v:#?}");
+			assert_snapshot!(v);
+		});
 	}
 }