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

--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -4,7 +4,7 @@
 use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_parser::{
 	ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName,
-	ForSpecData, IfElse, IfSpecData, ImportKind, Member, ObjBody, Param, ParamsDesc,
+	ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, Param, ParamsDesc,
 	ParserSettings, Slice, SliceDesc, Source, SourcePath, Spanned,
 };
 use rustc_hash::FxHashMap;
@@ -102,31 +102,30 @@
 	}
 	fn in_obj(obj: &ObjBody, out: &mut FoundImports) {
 		match obj {
-			ObjBody::MemberList(v) => {
-				for member in v {
-					match member {
-						Member::Field(FieldMember {
-							name,
-							params,
-							value,
-							..
-						}) => {
-							match name {
-								FieldName::Fixed(_) => {}
-								FieldName::Dyn(expr) => find_imports(expr, out),
-							}
-							if let Some(params) = params {
-								in_params(params, out);
-							}
-							find_imports(value, out);
-						}
-						Member::BindStmt(_) => todo!(),
-						Member::AssertStmt(assert) => {
-							find_imports(&assert.0, out);
-							if let Some(expr) = &assert.1 {
-								find_imports(expr, out);
-							}
-						}
+			ObjBody::MemberList(obj) => {
+				for FieldMember {
+					name,
+					params,
+					value,
+					..
+				} in &obj.fields
+				{
+					match name {
+						FieldName::Fixed(_) => {}
+						FieldName::Dyn(expr) => find_imports(expr, out),
+					}
+					if let Some(params) = params {
+						in_params(params, out);
+					}
+					find_imports(value, out);
+				}
+				for _ in &*obj.locals {
+					todo!()
+				}
+				for assert in &*obj.asserts {
+					find_imports(&assert.0, out);
+					if let Some(expr) = &assert.1 {
+						find_imports(expr, out);
 					}
 				}
 			}

4use jrsonnet_interner::IStr;4use jrsonnet_interner::IStr;
5use jrsonnet_parser::{5use jrsonnet_parser::{
6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,6	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,
7	ForSpecData, IfSpecData, ImportKind, LiteralType, Member, ObjBody, ParamsDesc, Spanned,7	ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers, ParamsDesc, Spanned,
8};8};
9use jrsonnet_types::ValType;9use jrsonnet_types::ValType;
10use rustc_hash::FxHashMap;10use rustc_hash::FxHashMap;
282}282}
283283
284#[allow(clippy::too_many_lines)]284#[allow(clippy::too_many_lines)]
285pub fn evaluate_member_list_object(ctx: Context, members: &[Member]) -> Result<ObjValue> {285pub fn evaluate_member_list_object(ctx: Context, members: &ObjMembers) -> Result<ObjValue> {
286	let mut builder = ObjValueBuilder::new();286	let mut builder = ObjValueBuilder::new();
287	let locals = Rc::new(287	let locals = members.locals.clone();
288		members
289			.iter()
290			.filter_map(|m| match m {
291				Member::BindStmt(bind) => Some(bind.clone()),
292				_ => None,
293			})
294			.collect::<Vec<_>>(),
295	);
296288
297	// We have single context for all fields, so we can cache binds289	// We have single context for all fields, so we can cache binds
298	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));290	let uctx = CachedUnbound::new(evaluate_object_locals(ctx.clone(), locals));
299291
300	for member in members {292	for field in &members.fields {
301		match member {293		evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), &field)?;
302			Member::Field(field) => {294	}
295
303				evaluate_field_member(&mut builder, ctx.clone(), uctx.clone(), field)?;296	if !members.asserts.is_empty() {
304			}
305			Member::AssertStmt(stmt) => {
306				#[derive(Trace)]297		#[derive(Trace)]
307				struct ObjectAssert<B: Trace> {298		struct ObjectAssert<B: Trace> {
308					uctx: B,299			uctx: B,
309					assert: Rc<AssertStmt>,300			asserts: Rc<Vec<AssertStmt>>,
310				}301		}
311				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {302		impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {
312					fn run(&self, sup_this: SupThis) -> Result<()> {303			fn run(&self, sup_this: SupThis) -> Result<()> {
313						let ctx = self.uctx.bind(sup_this)?;304				let ctx = self.uctx.bind(sup_this)?;
305				for assert in &*self.asserts {
314						evaluate_assert(ctx, &self.assert)306					evaluate_assert(ctx.clone(), &assert)?;
307				}
308				Ok(())
315					}309			}
316				}310		}
317				builder.assert(ObjectAssert {311		builder.assert(ObjectAssert {
318					uctx: uctx.clone(),312			uctx: uctx.clone(),
319					assert: stmt.clone(),313			asserts: members.asserts.clone(),
320				});314		});
321			}315	}
322			Member::BindStmt(_) => {316
323				// Already handled
324			}
325		}
326	}
327	Ok(builder.build())317	Ok(builder.build())
328}318}
329319
332		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,322		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,
333		ObjBody::ObjComp(obj) => {323		ObjBody::ObjComp(obj) => {
334			let mut builder = ObjValueBuilder::new();324			let mut builder = ObjValueBuilder::new();
335			let locals = Rc::new(325			let locals = obj.locals.clone();
336				obj.pre_locals
337					.iter()
338					.chain(obj.post_locals.iter())
339					.cloned()
340					.collect::<Vec<_>>(),
341			);
342			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {326			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {
343				let uctx = evaluate_object_locals(ctx.clone(), locals.clone());327				let uctx = evaluate_object_locals(ctx.clone(), locals.clone());
344328

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -47,10 +47,10 @@
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
-pub enum Member {
+pub(crate) enum Member {
 	Field(FieldMember),
 	BindStmt(BindSpec),
-	AssertStmt(Rc<AssertStmt>),
+	AssertStmt(AssertStmt),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
@@ -240,7 +240,7 @@
 	}
 }
 
-#[derive(Debug, Clone, PartialEq, Acyclic)]
+#[derive(Debug, PartialEq, Acyclic)]
 pub enum BindSpec {
 	Field {
 		into: Destruct,
@@ -275,15 +275,21 @@
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub struct ObjComp {
-	pub pre_locals: Vec<BindSpec>,
+	pub locals: Rc<Vec<BindSpec>>,
 	pub field: Rc<FieldMember>,
-	pub post_locals: Vec<BindSpec>,
 	pub compspecs: Vec<CompSpec>,
 }
 
 #[derive(Debug, PartialEq, Acyclic)]
+pub struct ObjMembers {
+	pub locals: Rc<Vec<BindSpec>>,
+	pub asserts: Rc<Vec<AssertStmt>>,
+	pub fields: Vec<FieldMember>,
+}
+
+#[derive(Debug, PartialEq, Acyclic)]
 pub enum ObjBody {
-	MemberList(Vec<Member>),
+	MemberList(ObjMembers),
 	ObjComp(ObjComp),
 }
 

--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -139,8 +139,8 @@
 			/ obj:destruct_object(s) {obj}
 
 		pub rule bind(s: &ParserSettings) -> expr::BindSpec
-			= into:destruct(s) _ "=" _ expr:expr(s) {expr::BindSpec::Field{into, value: Rc::new(expr)}}
-			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec::Function{name, params, value: Rc::new(expr)}}
+			= into:destruct(s) _ "=" _ value:expr(s) {expr::BindSpec::Field{into, value: Rc::new(value)}}
+			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {expr::BindSpec::Function{name, params, value: Rc::new(value)}}
 
 		pub rule assertion(s: &ParserSettings) -> expr::AssertStmt
 			= keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }
@@ -207,20 +207,35 @@
 			= keyword("local") _ bind:bind(s) {bind}
 		pub rule member(s: &ParserSettings) -> expr::Member
 			= bind:obj_local(s) {expr::Member::BindStmt(bind)}
-			/ assertion:assertion(s) {expr::Member::AssertStmt(Rc::new(assertion))}
+			/ assertion:assertion(s) {expr::Member::AssertStmt(assertion)}
 			/ field:field(s) {expr::Member::Field(field)}
 		pub rule objinside(s: &ParserSettings) -> expr::ObjBody
 			= pre_locals:(b: obj_local(s) comma() {b})* &"[" field:field(s) post_locals:(comma() b:obj_local(s) {b})* _ ("," _)? forspec:forspec(s) others:(_ rest:compspec(s) {rest})? {
 				let mut compspecs = vec![CompSpec::ForSpec(forspec)];
 				compspecs.extend(others.unwrap_or_default());
+				let mut locals = pre_locals;
+				locals.extend(post_locals);
 				expr::ObjBody::ObjComp(expr::ObjComp{
-					pre_locals,
+					locals: Rc::new(locals),
 					field: Rc::new(field),
-					post_locals,
 					compspecs,
 				})
 			}
-			/ members:(member(s) ** comma()) comma()? {expr::ObjBody::MemberList(members)}
+			/ members:(member(s) ** comma()) comma()? {
+				let mut locals = Vec::new();
+				let mut asserts = Vec::new();
+				let mut fields = Vec::new();
+				for member in members {
+					match member {
+						Member::Field(field_member) => fields.push(field_member),
+						Member::BindStmt(bind_spec) => locals.push(bind_spec),
+						Member::AssertStmt(assert_stmt) => asserts.push(assert_stmt),
+					}
+				}
+				expr::ObjBody::MemberList(ObjMembers {
+					locals: Rc::new(locals), asserts: Rc::new(asserts), fields
+				})
+			}
 		pub rule ifspec(s: &ParserSettings) -> IfSpecData
 			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}
 		pub rule forspec(s: &ParserSettings) -> ForSpecData

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__add_location_info_to_all_sub_expressions.snap
+++ b/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__add_location_info_to_all_sub_expressions.snap
@@ -7,12 +7,16 @@
         lhs: ObjExtend(
             Obj(
                 MemberList(
-                    [],
+                    ObjMembers {
+                        locals: [],
+                        asserts: [],
+                        fields: [],
+                    },
                 ),
             ) from virtual:<test>:0-2,
             MemberList(
-                [
-                    BindStmt(
+                ObjMembers {
+                    locals: [
                         Field {
                             into: Full(
                                 "x",
@@ -21,8 +25,9 @@
                                 1.0,
                             ) from virtual:<test>:15-16,
                         },
-                    ),
-                    Field(
+                    ],
+                    asserts: [],
+                    fields: [
                         FieldMember {
                             name: Fixed(
                                 "x",
@@ -34,14 +39,18 @@
                                 "x",
                             ) from virtual:<test>:21-22,
                         },
-                    ),
-                ],
+                    ],
+                },
             ),
         ) from virtual:<test>:0-24,
         op: Add,
         rhs: Obj(
             MemberList(
-                [],
+                ObjMembers {
+                    locals: [],
+                    asserts: [],
+                    fields: [],
+                },
             ),
         ) from virtual:<test>:27-29,
     },

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__empty_object.snap
+++ b/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__empty_object.snap
@@ -4,6 +4,10 @@
 ---
 Obj(
     MemberList(
-        [],
+        ObjMembers {
+            locals: [],
+            asserts: [],
+            fields: [],
+        },
     ),
 ) from virtual:<test>:0-2

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__missing_newline_between_comment_and_eof.snap
+++ b/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__missing_newline_between_comment_and_eof.snap
@@ -4,8 +4,10 @@
 ---
 Obj(
     MemberList(
-        [
-            Field(
+        ObjMembers {
+            locals: [],
+            asserts: [],
+            fields: [
                 FieldMember {
                     name: Fixed(
                         "a",
@@ -17,7 +19,7 @@
                         1.0,
                     ) from virtual:<test>:3-4,
                 },
-            ),
-        ],
+            ],
+        },
     ),
 ) from virtual:<test>:0-5