Add an iterator over all the required properties of a Vertex

trustfall_core/src/interpreter/hints/tests/mod.rs

@@ -591,10 +591,9 @@ mod static_property_values {
                     assert_eq!(vid(1), info.vid());
 
                     assert_eq!(vec![RequiredProperty::new("value".into()),
-                                    RequiredProperty::new("multiple".into()),
-                                    RequiredProperty::new("predecessor".into()),
-                                    RequiredProperty::new("__typename".into())
-                                ], info.required_properties());
+                                    RequiredProperty::new("__typename".into()),
+                                    RequiredProperty::new("name".into())
+                                ], info.required_properties().collect::<Vec<RequiredProperty>>());
                 })),
             }
             .into(),

trustfall_core/src/interpreter/hints/vertex_info.rs

@@ -35,7 +35,7 @@ pub trait VertexInfo: super::sealed::__Sealed {
     /// The type coercion (`... on SomeType`) applied by the query at this vertex, if any.
     fn coerced_to_type(&self) -> Option<&Arc<str>>;
 
-    fn required_properties(&self) -> Vec<RequiredProperty>;
+    fn required_properties(&self) -> Box<dyn Iterator<Item = RequiredProperty>>;
 
     /// Check whether the query demands this vertex property to have specific values:
     /// a single value, or one of a set or range of values. The candidate values
@@ -148,7 +148,7 @@ impl<T: InternalVertexInfo + super::sealed::__Sealed> VertexInfo for T {
 
     /// required_properties returns an iterator over all properties needed
     /// for this vertex.
-    fn required_properties(&self) -> Vec<RequiredProperty> {
+    fn required_properties(&self) -> Box<dyn Iterator<Item = RequiredProperty>> {
         let current_component = self.current_component();
 
         let current_vertex = self.current_vertex();
@@ -157,35 +157,10 @@ impl<T: InternalVertexInfo + super::sealed::__Sealed> VertexInfo for T {
         let mut properties: Vec<RequiredProperty> = current_component
             .outputs
             .values()
+            .filter(|c| c.vertex_id == current_vertex.vid)
             .map(|c| RequiredProperty::new(c.field_name.clone()))
             .collect::<Vec<RequiredProperty>>();
 
-        // extend with the edges from this vertex
-        properties.extend(
-            current_component
-                .edges
-                .values()
-                .map(|a| RequiredProperty::new(a.edge_name.clone()))
-                .collect::<Vec<RequiredProperty>>(),
-        );
-
-        properties.extend(
-            current_component
-                .folds
-                .values()
-                .map(|i| RequiredProperty::new(i.edge_name.clone()))
-                .collect::<Vec<RequiredProperty>>(),
-        );
-
-        // properties.extend(
-        //     current_component
-        //         .vertices
-        //         .values()
-        //         .filter(|v| v.vid != current_vertex.vid)
-        //         .map(|v| RequiredProperty::new(v.type_name.clone()))
-        //         .collect::<Vec<RequiredProperty>>(),
-        // );
-
         properties.extend(
             current_vertex
                 .filters
@@ -194,7 +169,24 @@ impl<T: InternalVertexInfo + super::sealed::__Sealed> VertexInfo for T {
                 .collect::<Vec<RequiredProperty>>(),
         );
 
-        properties
+        properties.extend(current_component.vertices.values().flat_map(|v| {
+            v.filters
+                .iter()
+                .filter(|f| match f.right() {
+                    Some(Argument::Tag(FieldRef::ContextField(ctx))) => {
+                        current_vertex.vid == ctx.vertex_id
+                    }
+                    Some(Argument::Tag(FieldRef::FoldSpecificField(fsf))) => {
+                        current_vertex.vid == fsf.fold_root_vid
+                    }
+                    _ => false,
+                })
+                .map(|f| f.right().unwrap().as_tag().unwrap().field_name().into())
+                .map(RequiredProperty::new)
+                .collect::<Vec<RequiredProperty>>()
+        }));
+
+        Box::new(properties.into_iter())
     }
 
     fn statically_required_property(&self, property: &str) -> Option<CandidateValue<&FieldValue>> {