feat: upgrade to hugr v0.27.1

Cargo.toml

@@ -44,17 +44,17 @@ large_enum_variant = "allow"
 [patch.crates-io]
 
 # Uncomment to use unreleased versions of hugr
-# hugr = { git = "https://github.com/quantinuum/hugr", "rev" = "de7b9f7581ae02cd80dff7b12794b55635903304" }
-# hugr-core = { git = "https://github.com/quantinuum/hugr", "rev" = "de7b9f7581ae02cd80dff7b12794b55635903304" }
-# hugr-cli = { git = "https://github.com/quantinuum/hugr", "rev" = "de7b9f7581ae02cd80dff7b12794b55635903304" }
-# hugr-llvm = { git = "https://github.com/quantinuum/hugr", "rev" = "de7b9f7581ae02cd80dff7b12794b55635903304" }
+#hugr = { git = "https://github.com/quantinuum/hugr", "rev" = "316fe8d8686b30e3ee64a404d98fd34f66089c42" }
+#hugr-core = { git = "https://github.com/quantinuum/hugr", "rev" = "316fe8d8686b30e3ee64a404d98fd34f66089c42" }
+#hugr-cli = { git = "https://github.com/quantinuum/hugr", "rev" = "316fe8d8686b30e3ee64a404d98fd34f66089c42" }
+#hugr-llvm = { git = "https://github.com/quantinuum/hugr", "rev" = "316fe8d8686b30e3ee64a404d98fd34f66089c42" }
 # portgraph = { git = "https://github.com/quantinuum/portgraph", rev = "68b96ac737e0c285d8c543b2d74a7aa80a18202c" }
 
 [workspace.dependencies]
 # Make sure to run `just recompile-eccs` if the hugr serialisation format changes.
-hugr = "0.27.0"
-hugr-core = "0.27.0"
-hugr-cli = "0.27.0"
+hugr = "0.27.1"
+hugr-core = "0.27.1"
+hugr-cli = "0.27.1"
 portgraph = "0.16.1"
 # There can only be one `pyo3` version in the whole workspace, so we use a
 # loose version constraint to prevent breaking changes in dependent crates where possible.

qis-compiler/Cargo.toml

@@ -43,7 +43,7 @@ typetag.workspace = true
 
 # Defined here so it can be overridden by the codspeed CI job
 # using `cargo add`.
-insta = "1.47.0"
+insta = "1.47.2"
 
 [package.metadata.cargo-machete]
 ignored = ["cbindgen", "pyo3-build-config"]

tket-qsystem/src/lib.rs

@@ -313,7 +313,6 @@ mod test {
         types::Signature,
     };
 
-    use hugr_core::hugr::internal::{HugrInternals, PortgraphNodeMap};
     use petgraph::visit::{Topo, Walker as _};
     use rstest::rstest;
     use tket::extension::{
@@ -388,13 +387,13 @@ mod test {
         }
         QSystemPass::default().run(&mut hugr).unwrap();
 
-        let (pg, node_map) = hugr.region_portgraph(main_node);
-        let topo_sorted = Topo::new(&pg).iter(&pg).collect_vec();
+        let sg = hugr.scheduling_graph(main_node);
+        let topo_sorted = Topo::new(sg.petgraph()).iter(&sg.petgraph()).collect_vec();
 
         let get_pos = |x| {
             topo_sorted
                 .iter()
-                .position(|&y| y == node_map.to_portgraph(x))
+                .position(|&y| y == sg.node_to_pg(x))
                 .unwrap()
         };
         assert!(get_pos(h_node) < get_pos(f_node));
@@ -403,7 +402,7 @@ mod test {
 
         for n in topo_sorted
             .iter()
-            .map(|&pg_n| node_map.from_portgraph(pg_n))
+            .map(|&pg_n| sg.pg_to_node(pg_n))
             .filter(|&n| FutureOpDef::try_from(hugr.get_optype(n)) == Ok(FutureOpDef::Read))
         {
             assert!(get_pos(call_node) < get_pos(n));

tket/Cargo.toml

@@ -92,7 +92,7 @@ proptest-recurse = { workspace = true }
 # Defined here so it can be overridden by the codspeed CI job
 # using `cargo add`.
 criterion = { version = "0.8.2", features = ["html_reports"] }
-insta = "1.47.0"
+insta = "1.47.2"
 
 [[bench]]
 name = "bench_main"

tket/src/circuit.rs

@@ -14,7 +14,7 @@ pub use command::{Command, CommandIterator};
 use hugr::extension::prelude::{NoopDef, TupleOpDef};
 use hugr::extension::simple_op::MakeOpDef;
 use hugr::hugr::views::sibling_subgraph::InvalidSubgraph;
-use hugr::hugr::views::{ExtractionResult, RootChecked, SiblingSubgraph};
+use hugr::hugr::views::{ExtractionResult, RootChecked, SchedulingGraph, SiblingSubgraph};
 use hugr::ops::handle::DataflowParentID;
 use itertools::Either::{Left, Right};
 
@@ -110,6 +110,10 @@ impl<T: HugrView> Circuit<T> {
         self.hugr.entrypoint()
     }
 
+    pub(crate) fn sched_graph(&self) -> SchedulingGraph<'_, T> {
+        self.hugr.scheduling_graph(self.parent())
+    }
+
     /// Get a reference to the HUGR containing the circuit.
     pub fn hugr(&self) -> &T {
         &self.hugr

tket/src/circuit/command.rs

@@ -286,6 +286,14 @@ impl<'circ, T: HugrView<Node = Node>> CommandIterator<'circ, T> {
             .map(|(linear_unit, port, _)| (Wire::new(circ.input_node(), port), linear_unit.index()))
             .collect();
 
+        #[expect(deprecated)] // When region_portgraph is removed from Hugr, either:
+        // (1) if we've already deprecated CommandIterator + Circuit by then, remove them
+        //     (1a) We could remove CommandIterator but keep Circuit, with a method on Circuit
+        //          returning a new struct (borrowing the Circuit) that contains the SchedulingGraph,
+        //          where the new struct defines a method returning an Iterator<Item=Node/Command>
+        //          (actually returning a struct holding the Topo).
+        // (2) reimplement here precomputing the Vec of nodes topsorted from the scheduling_graph
+        //     - this will give poor perf/high memory usage - and deprecate CommandIterator at that time.
         let (region, region_node_map) = circ.hugr().region_portgraph(circ.parent());
         let node_count = region.node_count();
         let nodes = pv::Topo::new(&region);

tket/src/modifier/modifier_resolver/dfg_modify.rs

@@ -17,7 +17,6 @@ use hugr::{
     std_extensions::collections::array::ArrayOpBuilder,
     types::{FuncTypeBase, Signature, TypeArg, TypeRow},
 };
-use hugr_core::hugr::internal::PortgraphNodeMap;
 use petgraph::visit::{Topo, Walker};
 
 use super::{DirWire, ModifierFlags, ModifierResolver, ModifierResolverErrors, PortExt};
@@ -58,14 +57,14 @@ impl<N: HugrNode> ModifierResolver<N> {
         let mut worklist = VecDeque::new();
         // This block is needed to appease the borrow checker.
         {
-            let (region_graph, node_map) = h.region_portgraph(n);
-            let mut topo: Vec<_> = Topo::new(&region_graph).iter(&region_graph).collect();
+            let sg = h.scheduling_graph(n);
+            let mut topo: Vec<_> = Topo::new(sg.petgraph()).iter(sg.petgraph()).collect();
             // Reverse the topological order if dagger is applied.
             if self.modifiers.dagger {
                 topo.reverse();
             }
             for old_n_id in topo {
-                worklist.push_back(node_map.from_portgraph(old_n_id));
+                worklist.push_back(sg.pg_to_node(old_n_id));
             }
         }
         self.with_worklist(worklist, |this| {

tket/src/passes/force_order.rs

@@ -1,7 +1,6 @@
 //! Provides [`force_order`], a tool for fixing the order of nodes in a Hugr.
 use std::{cmp::Reverse, collections::BinaryHeap, iter};
 
-use hugr_core::hugr::internal::PortgraphNodeMap;
 use hugr_core::{
     HugrView as _, Node,
     hugr::{HugrError, hugrmut::HugrMut},
@@ -56,15 +55,15 @@ pub fn force_order_by_key<H: HugrMut<Node = Node>, K: Ord>(
         // we filter out the input and output nodes from the topological sort
         let [i, o] = hugr.get_io(dp).unwrap();
         let ordered_nodes = {
-            let (region, node_map) = hugr.region_portgraph(dp);
-            let rank = |n| rank(hugr, node_map.from_portgraph(n));
-            let i_pg = node_map.to_portgraph(i);
-            let o_pg = node_map.to_portgraph(o);
-            let petgraph = NodeFiltered::from_fn(&region, |x| x != i_pg && x != o_pg);
+            let sg = hugr.scheduling_graph(dp);
+            let rank = |n| rank(hugr, sg.pg_to_node(n));
+            let i_pg = sg.node_to_pg(i);
+            let o_pg = sg.node_to_pg(o);
+            let petgraph = NodeFiltered::from_fn(sg.petgraph(), |x| x != i_pg && x != o_pg);
             ForceOrder::<_, portgraph::NodeIndex, _, _>::new(&petgraph, &rank)
                 .iter(&petgraph)
                 .filter_map(|x| {
-                    let x = node_map.from_portgraph(x);
+                    let x = sg.pg_to_node(x);
                     let expected_edge = Some(EdgeKind::StateOrder);
                     let optype = hugr.get_optype(x);
                     if optype.other_input() == expected_edge
@@ -208,7 +207,6 @@ mod test {
 
     use super::*;
     use hugr_core::builder::{BuildHandle, Dataflow, DataflowHugr, endo_sig};
-    use hugr_core::hugr::internal::HugrInternals;
     use hugr_core::ops::handle::{DataflowOpID, NodeHandle};
 
     use hugr_core::ops::{self, Value};
@@ -278,11 +276,11 @@ mod test {
         })
         .unwrap();
 
-        let (graph, node_map) = hugr.region_portgraph(hugr.entrypoint());
+        let sg = hugr.scheduling_graph(hugr.entrypoint());
 
-        let topo_sorted = Topo::new(&graph)
-            .iter(&graph)
-            .map(|n| node_map.from_portgraph(n))
+        let topo_sorted = Topo::new(sg.petgraph())
+            .iter(sg.petgraph())
+            .map(|n| sg.pg_to_node(n))
             .filter(|n| rank_map.contains_key(n))
             .collect_vec();
         hugr.validate().unwrap();

tket/src/passes/redundant_order_edges.rs

@@ -3,7 +3,6 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 
 use hugr_core::core::HugrNode;
-use hugr_core::hugr::internal::PortgraphNodeMap;
 use hugr_core::hugr::{HugrError, hugrmut::HugrMut};
 use hugr_core::ops::{OpTag, OpTrait};
 use hugr_core::{HugrView, IncomingPort, Node, OutgoingPort};
@@ -67,10 +66,10 @@ impl RedundantOrderEdgesPass {
         let mut to_remove = Vec::new();
 
         // Traverse the region in topological order.
-        let (region, node_map) = hugr.region_portgraph(parent);
-        let postorder = petgraph::visit::Topo::new(&region);
-        for pg_child in postorder.iter(&region) {
-            let child = node_map.from_portgraph(pg_child);
+        let sg = hugr.scheduling_graph(parent);
+        let postorder = petgraph::visit::Topo::new(sg.petgraph());
+        for pg_child in postorder.iter(sg.petgraph()) {
+            let child = sg.pg_to_node(pg_child);
             let op = hugr.get_optype(child);
 
             // If the child itself is a region (parent) and we are running recursively, add the child to the region candidates.
@@ -142,7 +141,7 @@ impl RedundantOrderEdgesPass {
             to_remove.extend(removable_edges);
         }
         // Release the hugr borrow so we can mutate it.
-        drop(region);
+        drop(sg);
         let edges_removed = to_remove.len();
 
         for edge in to_remove {

tket/src/passes/untuple.rs

@@ -2,12 +2,12 @@
 
 use std::collections::VecDeque;
 
+use hugr::hugr::views::sibling_subgraph::SchedGraphChecker;
 use hugr_core::builder::{DFGBuilder, Dataflow, DataflowHugr};
 use hugr_core::extension::prelude::{MakeTuple, UnpackTuple};
 use hugr_core::hugr::SimpleReplacementError;
 use hugr_core::hugr::hugrmut::HugrMut;
 use hugr_core::hugr::views::SiblingSubgraph;
-use hugr_core::hugr::views::sibling_subgraph::TopoConvexChecker;
 use hugr_core::ops::{OpTrait, OpType};
 use hugr_core::types::Type;
 use hugr_core::{HugrView, Node, PortIndex, SimpleReplacement};
@@ -80,8 +80,9 @@ fn find_rewrites<H: HugrView>(
 
     while let Some(parent) = children_queue.pop_front() {
         // Required to create SimpleReplacements.
-        // Reset for each parent as `TopoConvexChecker` is tied to a specific parent node.
-        let mut convex_checker: Option<TopoConvexChecker<H>> = None;
+        // Reset for each parent as `SchedGraphChecker` and all `HugrConvexChecker`s
+        // are tied to a specific parent node.
+        let mut convex_checker: Option<SchedGraphChecker<H>> = None;
 
         for node in hugr.children(parent) {
             let op = hugr.get_optype(node);
@@ -138,7 +139,7 @@ fn is_unpack_tuple(optype: &OpType) -> bool {
 /// Otherwise, return None.
 fn make_rewrite<'h, T: HugrView>(
     hugr: &'h T,
-    convex_checker: &mut Option<TopoConvexChecker<'h, T>>,
+    convex_checker: &mut Option<SchedGraphChecker<'h, T>>,
     node: T::Node,
     op: &OpType,
 ) -> Option<SimpleReplacement<T::Node>> {
@@ -203,14 +204,15 @@ fn make_rewrite<'h, T: HugrView>(
 /// and `other_tuple_links` other operations.
 fn remove_pack_unpack<'h, T: HugrView>(
     hugr: &'h T,
-    convex_checker: &mut Option<TopoConvexChecker<'h, T>>,
+    convex_checker: &mut Option<SchedGraphChecker<'h, T>>,
     tuple_types: &[Type],
     pack_node: T::Node,
     unpack_nodes: Vec<T::Node>,
     num_other_outputs: usize,
 ) -> SimpleReplacement<T::Node> {
     let parent = hugr.get_parent(pack_node).expect("pack_node has no parent");
-    let checker = convex_checker.get_or_insert_with(|| TopoConvexChecker::new(hugr, parent));
+    let checker =
+        convex_checker.get_or_insert_with(|| SchedGraphChecker::new(hugr.scheduling_graph(parent)));
 
     let mut nodes = unpack_nodes.clone();
     nodes.push(pack_node);

tket/src/passes/utils/chunks.rs

@@ -9,13 +9,13 @@ use std::ops::{Index, IndexMut};
 use derive_more::From;
 use hugr::builder::{Container, FunctionBuilder};
 use hugr::hugr::hugrmut::HugrMut;
-use hugr::hugr::views::sibling_subgraph::TopoConvexChecker;
+use hugr::hugr::views::sibling_subgraph::{HugrConvexChecker, SchedGraphChecker};
 use hugr::hugr::views::{RootChecked, SiblingSubgraph};
 use hugr::hugr::{HugrError, NodeMetadataMap};
 use hugr::ops::OpType;
 use hugr::ops::handle::DataflowParentID;
 use hugr::types::Signature;
-use hugr::{Hugr, HugrView, IncomingPort, Node, OutgoingPort, PortIndex, Wire};
+use hugr::{HugrView, IncomingPort, Node, OutgoingPort, PortIndex, Wire};
 use hugr_core::hugr::internal::{HugrInternals, HugrMutInternals as _};
 use itertools::Itertools;
 use rayon::iter::{IntoParallelIterator, IntoParallelRefMutIterator, ParallelIterator};
@@ -52,7 +52,7 @@ impl Chunk {
     pub(self) fn extract(
         circ: &Circuit,
         nodes: impl IntoIterator<Item = Node>,
-        checker: &TopoConvexChecker<'_, Hugr>,
+        checker: &impl HugrConvexChecker<Node>,
     ) -> Self {
         let subgraph = SiblingSubgraph::try_from_nodes_with_checker(
             nodes.into_iter().collect_vec(),
@@ -283,7 +283,7 @@ impl CircuitChunks {
             .collect();
 
         let mut chunks = Vec::new();
-        let convex_checker = TopoConvexChecker::new(circ.hugr(), circ.parent());
+        let convex_checker = SchedGraphChecker::new(circ.sched_graph());
         let mut running_cost = C::default();
         let mut current_group = 0;
         for (_, commands) in &circ.commands().map(|cmd| cmd.node()).chunk_by(|&node| {