Use row_contains_bottom for CFG+DFG, and augment unpack_first(=>_no_b…

…ottom)

hugr-passes/src/dataflow/datalog.rs

@@ -194,7 +194,10 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
         dfg_node(n) <-- node(n), if ctx.get_optype(*n).is_dfg();
 
         out_wire_value(i, OutgoingPort::from(p.index()), v) <-- dfg_node(dfg),
-          input_child(dfg, i), in_wire_value(dfg, p, v);
+          input_child(dfg, i),
+          node_in_value_row(dfg, row),
+          if !row_contains_bottom(&row[..]), // Treat the DFG as a scheduling barrier
+          for (p, v) in row[..].iter().enumerate();
 
         out_wire_value(dfg, OutgoingPort::from(p.index()), v) <-- dfg_node(dfg),
             output_child(dfg, o), in_wire_value(o, p, v);
@@ -213,7 +216,7 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
             output_child(tl, out_n),
             node_in_value_row(out_n, out_in_row), // get the whole input row for the output node...
             // ...and select just what's possible for CONTINUE_TAG, if anything
-            if let Some(fields) = out_in_row.unpack_first(TailLoop::CONTINUE_TAG, tailloop.just_inputs.len()),
+            if let Some(fields) = out_in_row.unpack_first_no_bottom(TailLoop::CONTINUE_TAG, tailloop.just_inputs.len()),
             for (out_p, v) in fields.enumerate();
 
         // Output node of child region propagate to outputs of tail loop
@@ -222,7 +225,7 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
             output_child(tl, out_n),
             node_in_value_row(out_n, out_in_row), // get the whole input row for the output node...
             // ... and select just what's possible for BREAK_TAG, if anything
-            if let Some(fields) = out_in_row.unpack_first(TailLoop::BREAK_TAG, tailloop.just_outputs.len()),
+            if let Some(fields) = out_in_row.unpack_first_no_bottom(TailLoop::BREAK_TAG, tailloop.just_outputs.len()),
             for (out_p, v) in fields.enumerate();
 
         // Conditional --------------------
@@ -239,7 +242,7 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
           input_child(case, i_node),
           node_in_value_row(cond, in_row),
           let conditional = ctx.get_optype(*cond).as_conditional().unwrap(),
-          if let Some(fields) = in_row.unpack_first(*case_index, conditional.sum_rows[*case_index].len()),
+          if let Some(fields) = in_row.unpack_first_no_bottom(*case_index, conditional.sum_rows[*case_index].len()),
           for (out_p, v) in fields.enumerate();
 
         // outputs of case nodes propagate to outputs of conditional *if* case reachable
@@ -274,7 +277,9 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
             cfg_node(cfg),
             if let Some(entry) = ctx.children(*cfg).next(),
             input_child(entry, i_node),
-            in_wire_value(cfg, p, v);
+            node_in_value_row(cfg, row),
+            if !row_contains_bottom(&row[..]),
+            for (p, v) in row[..].iter().enumerate();
 
         // In `CFG` <Node>, values fed along a control-flow edge to <Node>
         //     come out of Value outports of <Node>:
@@ -293,7 +298,7 @@ pub(super) fn run_datalog<V: AbstractValue, C: DFContext<V>>(
             output_child(pred, out_n),
             _cfg_succ_dest(cfg, succ, dest),
             node_in_value_row(out_n, out_in_row),
-            if let Some(fields) = out_in_row.unpack_first(succ_n, df_block.sum_rows.get(succ_n).unwrap().len()),
+            if let Some(fields) = out_in_row.unpack_first_no_bottom(succ_n, df_block.sum_rows.get(succ_n).unwrap().len()),
             for (out_p, v) in fields.enumerate();
 
         // Call --------------------

hugr-passes/src/dataflow/value_row.rs

@@ -8,7 +8,7 @@ use std::{
 use ascent::{lattice::BoundedLattice, Lattice};
 use itertools::zip_eq;
 
-use super::{AbstractValue, PartialValue};
+use super::{row_contains_bottom, AbstractValue, PartialValue};
 
 #[derive(PartialEq, Clone, Debug, Eq, Hash)]
 pub(super) struct ValueRow<V>(Vec<PartialValue<V>>);
@@ -25,16 +25,19 @@ impl<V: AbstractValue> ValueRow<V> {
         r
     }
 
-    /// The first value in this ValueRow must be a sum;
-    /// returns a new ValueRow given by unpacking the elements of the specified variant of said first value,
-    /// then appending the rest of the values in this row.
-    pub fn unpack_first(
+    /// If the first value in this ValueRow is a sum, that might contain
+    /// the specified tag, then unpack the elements of that tag, append the rest
+    /// of this ValueRow, and if none of the elements of that row [contain bottom](PartialValue::contains_bottom),
+    /// return it.
+    /// Otherwise (if no such tag, or values contain bottom), return None.
+    pub fn unpack_first_no_bottom(
         &self,
         variant: usize,
         len: usize,
     ) -> Option<impl Iterator<Item = PartialValue<V>>> {
         let vals = self[0].variant_values(variant, len)?;
-        Some(vals.into_iter().chain(self.0[1..].to_owned()))
+        (!row_contains_bottom(vals.iter().chain(self.0[1..].iter())))
+            .then(|| vals.into_iter().chain(self.0[1..].to_owned()))
     }
 }