implement query and/or

testsuite/query-and-or-prec/main.tri

···
+module debug at "trilogy:debug" use dbg
+
+proc main!() {
+  for a = 1 and b = 2 or b = 3 and a = 4 {
+    dbg!(a : b)
+  }
+}

testsuite/query-and-or-prec/spec.toml

···
+output = "1:2\n4:3\n"

testsuite/query-conjunction/main.tri

···
+module debug at "trilogy:debug" use dbg
+
+rule nums(1)
+rule nums(2)
+rule nums(3)
+
+proc main!() {
+  for a = 5 and b = 10 {
+    dbg!(a : b)
+  }
+
+  for nums(a) and nums(b) {
+    dbg!(a : b)
+  }
+}

testsuite/query-conjunction/spec.toml

···
+output = "5:10\n1:1\n1:2\n1:3\n2:1\n2:2\n2:3\n3:1\n3:2\n3:3\n"

testsuite/query-disjunction/main.tri

···
+module debug at "trilogy:debug" use dbg
+
+rule val_a(1)
+rule val_a(2)
+rule val_a(3)
+
+rule val_b(4)
+rule val_b(5)
+rule val_b(6)
+
+proc main!() {
+  for a = 5 or a = 10 {
+    dbg!(a)
+  }
+
+  for val_a(a) or val_b(a) {
+    dbg!(a)
+  }
+}

testsuite/query-disjunction/spec.toml

···
+output = "5\n10\n1\n2\n3\n4\n5\n6\n"

trilogy-llvm/src/expression/mod.rs

···
         self.bind_temporary(next_iteration);
         if let Some(value) = self.compile_expression(&expr.value, name) {
             let next_iteration = self.use_temporary(next_iteration).unwrap();
-            self.call_known_continuation(next_iteration, value);
+            self.trilogy_value_destroy(value);
+            self.void_call_continuation(next_iteration);
         }
 
         self.become_continuation_point(done_continuation_point);

trilogy-llvm/src/query.rs

···
                     )?);
                 }
 
-                // Wrap the next iteration with our own, as a lookup requires some cleanup
-                // before starting its next internal iteration.
-                let next_iteration_with_cleanup = self.add_continuation("rule_query_cleanup");
-                let (next_iteration_with_cleanup_continuation, next_iteration_with_cleanup_cp) =
-                    self.capture_current_continuation(next_iteration_with_cleanup, "pass_next");
-                self.call_known_continuation(
-                    self.use_temporary(next_to).unwrap(),
-                    next_iteration_with_cleanup_continuation,
+                self.next_cleanup(
+                    next_iteration_inner,
+                    next_to,
+                    bound_ids,
+                    bound_before_lookup,
+                    "rule_query_cleanup",
                 );
-                // The cleanup: destroy all variables that were unbound on the way in. This uses
-                // very similar detection as with patterns, noting that which variables are bound
-                // at iteration time can be determined statically as we make the pass through the
-                // query's IR.
-                self.become_continuation_point(next_iteration_with_cleanup_cp);
-                self.begin_next_function(next_iteration_with_cleanup);
-                for id in bound_ids[bound_before_lookup..]
-                    .iter()
-                    .filter(|id| !bound_ids[0..bound_before_lookup].contains(id))
-                {
-                    let var = self.get_variable(id).unwrap().ptr();
-                    self.trilogy_value_destroy(var);
-                }
-                let next_iteration = self.use_temporary(next_iteration_inner).unwrap();
-                self.call_known_continuation(next_iteration, self.get_continuation(""));
+            }
+            ir::QueryValue::Disjunction(disj) => {
+                let disj_second_fn = self.add_continuation("disj.second");
+                let (disj_second, disj_second_cp) =
+                    self.capture_current_continuation(disj_second_fn, "disj.second");
+                let next_of_first = self.compile_iterator(&disj.0, disj_second)?;
+                self.call_known_continuation(self.use_temporary(next_to).unwrap(), next_of_first);
+
+                self.become_continuation_point(disj_second_cp);
+                self.begin_next_function(disj_second_fn);
+                let next_of_second = self.compile_iterator(&disj.1, done_to)?;
+                self.call_known_continuation(self.use_temporary(next_to).unwrap(), next_of_second);
             }
-            ir::QueryValue::Disjunction(..) => todo!(),
-            ir::QueryValue::Conjunction(..) => todo!(),
+            ir::QueryValue::Conjunction(conj) => {
+                let next_of_first = self.compile_iterator(&conj.0, done_to)?;
+                self.bind_temporary(next_of_first);
+                let next_of_second = self.compile_iterator(&conj.1, next_of_first)?;
+                let next_to = self.use_temporary(next_to).unwrap();
+                self.call_known_continuation(next_to, next_of_second);
+            }
             ir::QueryValue::Implication(..) => todo!(),
             ir::QueryValue::Alternative(..) => todo!(),
             ir::QueryValue::Direct(unification) => {
                 let rvalue = self.compile_expression(&unification.expression, "rvalue")?;
-                self.compile_pattern_match(&unification.pattern, rvalue, done_to)?;
-                self.next_deterministic(next_to, done_to, "assign_next");
+                let pre_len = bound_ids.len();
+                bound_ids.extend(self.compile_pattern_match(
+                    &unification.pattern,
+                    rvalue,
+                    done_to,
+                )?);
+                self.next_cleanup(done_to, next_to, bound_ids, pre_len, "assign_next");
             }
             ir::QueryValue::Element(..) => todo!(),
             ir::QueryValue::Not(..) => todo!(),
···
         self.begin_next_function(next_iteration);
         let done_to = self.use_temporary(done_to).unwrap();
         self.void_call_continuation(done_to);
+    }
+
+    fn next_cleanup(
+        &self,
+        next_iteration: PointerValue<'ctx>,
+        next_to: PointerValue<'ctx>,
+        bound_ids: &[Id],
+        keep_ids: usize,
+        name: &str,
+    ) {
+        // Wrap the next iteration with our own, as a lookup requires some cleanup
+        // before starting its next internal iteration.
+        let next_iteration_with_cleanup = self.add_continuation(name);
+        let (next_iteration_with_cleanup_continuation, next_iteration_with_cleanup_cp) =
+            self.capture_current_continuation(next_iteration_with_cleanup, name);
+        self.call_known_continuation(
+            self.use_temporary(next_to).unwrap(),
+            next_iteration_with_cleanup_continuation,
+        );
+
+        // The cleanup: destroy all variables that were unbound on the way in. This uses
+        // very similar detection as with patterns, noting that which variables are bound
+        // at iteration time can be determined statically as we make the pass through the
+        // query's IR.
+        self.become_continuation_point(next_iteration_with_cleanup_cp);
+        self.begin_next_function(next_iteration_with_cleanup);
+        for id in bound_ids[keep_ids..]
+            .iter()
+            .filter(|id| !bound_ids[0..keep_ids].contains(id))
+        {
+            let var = self.get_variable(id).unwrap().ptr();
+            self.trilogy_value_destroy(var);
+        }
+        let next_iteration = self.use_temporary(next_iteration).unwrap();
+        self.void_call_continuation(next_iteration);
     }
 }