Add CandidateValue::All enum variant.

obi1kenobi · obi1kenobi · commit 97937959da8a · 2023-02-05T02:57:33.000Z
diff --git a/trustfall_core/src/interpreter/hints/candidates.rs b/trustfall_core/src/interpreter/hints/candidates.rs
@@ -7,6 +7,8 @@ pub enum CandidateValue<T> {
     Impossible,       // statically determined that no values fit
     Single(T),        // there's only one value that fits
     Multiple(Vec<T>), // there are multiple values that fit
+    All,              // all values are possible for this specific entry
+                      // (e.g. used for tag-from-non-existent-optional cases)
 }
 
 impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {
@@ -28,6 +30,7 @@ impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {
                             *self = CandidateValue::Impossible;
                         }
                     }
+                    Self::All => {} // self is unchanged.
                 }
             }
             Self::Multiple(multiple) => {
@@ -53,8 +56,13 @@ impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {
                             *self = Self::Single(first);
                         } // otherwise it stays Multiple and we already mutated the Vec it holds
                     }
+                    Self::All => {} // self is unchanged.
                 }
             }
+            Self::All => {
+                // Whatever the other candidate was. It can't be any wider than Self::All.
+                *self = other;
+            }
         }
     }
 }
@@ -191,6 +199,15 @@ mod tests {
                 Multiple(vec![&three, &two]),
                 Multiple(vec![&two, &three]),
             ),
+            //
+            // Merging Candidate::All from either position produces whatever the other value was.
+            (All, Impossible, Impossible),
+            (Impossible, All, Impossible),
+            (All, Single(&one), Single(&one)),
+            (Single(&one), All, Single(&one)),
+            (All, Multiple(vec![&one, &two]), Multiple(vec![&one, &two])),
+            (Multiple(vec![&one, &two]), All, Multiple(vec![&one, &two])),
+            (All, All, All),
         ];
 
         for (original, merged, expected) in test_cases {
diff --git a/trustfall_core/src/interpreter/hints/mod.rs b/trustfall_core/src/interpreter/hints/mod.rs
@@ -99,12 +99,12 @@ pub trait VertexInfo {
 
     // non-optional, non-recursed, non-folded edge
     // TODO: What happens if the same edge exists more than once in a given scope?
-    fn required_edge(&self, edge_name: &str) -> Option<EdgeInfo>;
+    fn first_required_edge(&self, edge_name: &str) -> Option<EdgeInfo>;
 
     // optional, recursed, or folded edge;
     // recursed because recursion always starts at depth 0
     // TODO: What happens if the same edge exists more than once in a given scope?
-    fn optional_edge(&self, edge_name: &str) -> Option<EdgeInfo>;
+    fn first_edge(&self, edge_name: &str) -> Option<EdgeInfo>;
 }
 
 #[non_exhaustive]
@@ -238,7 +238,8 @@ impl VertexInfo for LocalQueryInfo {
                     return Some(DynamicallyResolvedValue {
                         query: self.query.clone(),
                         vid: vertex.vid,
-                        resolve_on_component: self.query.query.indexed_query.vids[&vertex.vid].clone(),
+                        resolve_on_component: self.query.query.indexed_query.vids[&vertex.vid]
+                            .clone(),
                         context_field: context_field.clone(),
                         is_multiple: false,
                     });
@@ -247,7 +248,8 @@ impl VertexInfo for LocalQueryInfo {
                     return Some(DynamicallyResolvedValue {
                         query: self.query.clone(),
                         vid: vertex.vid,
-                        resolve_on_component: self.query.query.indexed_query.vids[&vertex.vid].clone(),
+                        resolve_on_component: self.query.query.indexed_query.vids[&vertex.vid]
+                            .clone(),
                         context_field: context_field.clone(),
                         is_multiple: true,
                     });
@@ -264,7 +266,7 @@ impl VertexInfo for LocalQueryInfo {
     // }
 
     // non-optional, non-recursed, non-folded edge
-    fn required_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
+    fn first_required_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
         // TODO: What happens if the same edge exists more than once in a given scope?
         let component = self.current_component();
         let current_vertex = self.current_vertex();
@@ -277,7 +279,7 @@ impl VertexInfo for LocalQueryInfo {
         first_matching_edge.map(|edge| self.make_non_folded_edge_info(edge.as_ref()))
     }
 
-    fn optional_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
+    fn first_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
         // TODO: What happens if the same edge exists more than once in a given scope?
         let component = self.current_component();
         let current_vertex = self.current_vertex();
@@ -410,7 +412,9 @@ impl VertexInfo for NeighboringQueryInfo {
                             query: self.query.clone(),
                             vid: vertex.vid,
                             context_field: context_field.clone(),
-                            resolve_on_component: self.query.query.indexed_query.vids[&self.starting_vertex].clone(),
+                            resolve_on_component: self.query.query.indexed_query.vids
+                                [&self.starting_vertex]
+                                .clone(),
                             is_multiple: false,
                         });
                     }
@@ -421,7 +425,9 @@ impl VertexInfo for NeighboringQueryInfo {
                             query: self.query.clone(),
                             vid: vertex.vid,
                             context_field: context_field.clone(),
-                            resolve_on_component: self.query.query.indexed_query.vids[&self.starting_vertex].clone(),
+                            resolve_on_component: self.query.query.indexed_query.vids
+                                [&self.starting_vertex]
+                                .clone(),
                             is_multiple: true,
                         });
                     }
@@ -437,7 +443,7 @@ impl VertexInfo for NeighboringQueryInfo {
     //     todo!()
     // }
 
-    fn required_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
+    fn first_required_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
         // TODO: What happens if the same edge exists more than once in a given scope?
         let component = self.current_component();
         let current_vertex = self.current_vertex();
@@ -450,7 +456,7 @@ impl VertexInfo for NeighboringQueryInfo {
         first_matching_edge.map(|edge| self.make_non_folded_edge_info(edge.as_ref()))
     }
 
-    fn optional_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
+    fn first_edge(&self, edge_name: &str) -> Option<EdgeInfo> {
         // TODO: What happens if the same edge exists more than once in a given scope?
         let component = self.current_component();
         let current_vertex = self.current_vertex();
@@ -498,11 +504,30 @@ impl DynamicallyResolvedValue {
             &self.context_field,
             contexts,
         );
+        let context_field_vid = self.context_field.vertex_id;
+        let nullable_context_field = self.context_field.field_type.nullable;
         if self.is_multiple {
             Box::new(iterator.map(move |(ctx, value)| {
                 match value {
                     FieldValue::List(v) => (ctx, CandidateValue::Multiple(v)),
-                    FieldValue::Null => (ctx, CandidateValue::Impossible), // nullable field tagged
+                    FieldValue::Null => {
+                        // Either a nullable field was tagged, or
+                        // the @tag is inside an @optional scope that doesn't exist.
+                        let candidate = if ctx.tokens[&context_field_vid].is_none() {
+                            // @optional scope that didn't exist. Our query rules say that
+                            // any filters using this tag *must* pass.
+                            CandidateValue::All
+                        } else {
+                            // The field must have been nullable.
+                            debug_assert!(
+                                nullable_context_field,
+                                "tagged field {:?} was not nullable but received a null value for it",
+                                self.context_field,
+                            );
+                            CandidateValue::Impossible
+                        };
+                        (ctx, candidate)
+                    }
                     bad_value => {
                         panic!(
                             "\
@@ -513,7 +538,27 @@ tagged field named {} of type {:?} produced an invalid value: {bad_value:?}",
                 }
             }))
         } else {
-            Box::new(iterator.map(|(ctx, value)| (ctx, CandidateValue::Single(value))))
+            Box::new(iterator.map(move |(ctx, value)| match value {
+                null_value @ FieldValue::Null => {
+                    // Either a nullable field was tagged, or
+                    // the @tag is inside an @optional scope that doesn't exist.
+                    let candidate = if ctx.tokens[&context_field_vid].is_none() {
+                        // @optional scope that didn't exist. Our query rules say that
+                        // any filters using this tag *must* pass.
+                        CandidateValue::All
+                    } else {
+                        // The field must have been nullable.
+                        debug_assert!(
+                            nullable_context_field,
+                            "tagged field {:?} was not nullable but received a null value for it",
+                            self.context_field,
+                        );
+                        CandidateValue::Single(null_value)
+                    };
+                    (ctx, candidate)
+                }
+                other_value => (ctx, CandidateValue::Single(other_value)),
+            }))
         }
     }
 }
diff --git a/trustfall_core/src/interpreter/mod.rs b/trustfall_core/src/interpreter/mod.rs
@@ -26,7 +26,7 @@ pub mod trace;
 #[derive(Debug, Clone)]
 pub struct DataContext<DataToken: Clone + Debug> {
     pub current_token: Option<DataToken>,
-    tokens: BTreeMap<Vid, Option<DataToken>>,
+    pub(crate) tokens: BTreeMap<Vid, Option<DataToken>>,
     values: Vec<FieldValue>,
     suspended_tokens: Vec<Option<DataToken>>,
     folded_contexts: BTreeMap<Eid, Vec<DataContext<DataToken>>>,
diff --git a/trustfall_core/src/ir/value.rs b/trustfall_core/src/ir/value.rs
@@ -138,7 +138,10 @@ impl FieldValue {
         }
     }
 
-    pub fn as_vec_with<'a, T>(&'a self, inner: impl Fn(&'a FieldValue) -> Option<T>) -> Option<Vec<T>> {
+    pub fn as_vec_with<'a, T>(
+        &'a self,
+        inner: impl Fn(&'a FieldValue) -> Option<T>,
+    ) -> Option<Vec<T>> {
         match self {
             FieldValue::List(l) => {
                 let maybe_vec: Option<Vec<T>> = l.iter().map(inner).collect();

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ pub enum CandidateValue<T> {`
`7`	`7`	`Impossible, // statically determined that no values fit`
`8`	`8`	`Single(T), // there's only one value that fits`
`9`	`9`	`Multiple(Vec<T>), // there are multiple values that fit`
	`10`	`+ All, // all values are possible for this specific entry`
	`11`	`+ // (e.g. used for tag-from-non-existent-optional cases)`
`10`	`12`	`}`
`11`	`13`
`12`	`14`	`impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {`
`@@ -28,6 +30,7 @@ impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {`
`28`	`30`	`*self = CandidateValue::Impossible;`
`29`	`31`	`}`
`30`	`32`	`}`
	`33`	`+ Self::All => {} // self is unchanged.`
`31`	`34`	`}`
`32`	`35`	`}`
`33`	`36`	`Self::Multiple(multiple) => {`
`@@ -53,8 +56,13 @@ impl<T: Debug + Clone + PartialEq + Eq> CandidateValue<T> {`
`53`	`56`	`*self = Self::Single(first);`
`54`	`57`	`} // otherwise it stays Multiple and we already mutated the Vec it holds`
`55`	`58`	`}`
	`59`	`+ Self::All => {} // self is unchanged.`
`56`	`60`	`}`
`57`	`61`	`}`
	`62`	`+ Self::All => {`
	`63`	`+ // Whatever the other candidate was. It can't be any wider than Self::All.`
	`64`	`+ *self = other;`
	`65`	`+ }`
`58`	`66`	`}`
`59`	`67`	`}`
`60`	`68`	`}`
`@@ -191,6 +199,15 @@ mod tests {`
`191`	`199`	`Multiple(vec![&three, &two]),`
`192`	`200`	`Multiple(vec![&two, &three]),`
`193`	`201`	`),`
	`202`	`+ //`
	`203`	`+ // Merging Candidate::All from either position produces whatever the other value was.`
	`204`	`+ (All, Impossible, Impossible),`
	`205`	`+ (Impossible, All, Impossible),`
	`206`	`+ (All, Single(&one), Single(&one)),`
	`207`	`+ (Single(&one), All, Single(&one)),`
	`208`	`+ (All, Multiple(vec![&one, &two]), Multiple(vec![&one, &two])),`
	`209`	`+ (Multiple(vec![&one, &two]), All, Multiple(vec![&one, &two])),`
	`210`	`+ (All, All, All),`
`194`	`211`	`];`
`195`	`212`
`196`	`213`	`for (original, merged, expected) in test_cases {`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,10 @@ impl FieldValue {`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`- pub fn as_vec_with<'a, T>(&'a self, inner: impl Fn(&'a FieldValue) -> Option<T>) -> Option<Vec<T>> {`
	`141`	`+ pub fn as_vec_with<'a, T>(`
	`142`	`+ &'a self,`
	`143`	`+ inner: impl Fn(&'a FieldValue) -> Option<T>,`
	`144`	`+ ) -> Option<Vec<T>> {`
`142`	`145`	`match self {`
`143`	`146`	`FieldValue::List(l) => {`
`144`	`147`	`let maybe_vec: Option<Vec<T>> = l.iter().map(inner).collect();`