feat: Normalize CFGs

hugr-core/src/hugr/patch/inline_dfg.rs

@@ -3,36 +3,37 @@
 //! and deleting the DFG along with its Input + Output
 
 use super::{PatchHugrMut, PatchVerification};
+use crate::core::HugrNode;
 use crate::ops::handle::{DfgID, NodeHandle};
 use crate::{HugrView, IncomingPort, Node, OutgoingPort, PortIndex};
 
 /// Structure identifying an `InlineDFG` rewrite from the spec
-pub struct InlineDFG(pub DfgID);
+pub struct InlineDFG<N = Node>(pub DfgID<N>);
 
 /// Errors from an [`InlineDFG`] rewrite.
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 #[non_exhaustive]
-pub enum InlineDFGError {
+pub enum InlineDFGError<N = Node> {
     /// Node to inline was not a DFG. (E.g. node has been overwritten since the `DfgID` originated.)
     #[error("{node} was not a DFG")]
     NotDFG {
         /// The node we tried to inline
-        node: Node,
+        node: N,
     },
     /// The DFG node is the hugr entrypoint
     #[error("Cannot inline the entrypoint node, {node}")]
     CantInlineEntrypoint {
         /// The node we tried to inline
-        node: Node,
+        node: N,
     },
 }
 
-impl PatchVerification for InlineDFG {
-    type Error = InlineDFGError;
+impl<N: HugrNode> PatchVerification for InlineDFG<N> {
+    type Error = InlineDFGError<N>;
 
-    type Node = Node;
+    type Node = N;
 
-    fn verify(&self, h: &impl crate::HugrView<Node = Node>) -> Result<(), Self::Error> {
+    fn verify(&self, h: &impl crate::HugrView<Node = N>) -> Result<(), Self::Error> {
         let n = self.0.node();
         if h.get_optype(n).as_dfg().is_none() {
             return Err(InlineDFGError::NotDFG { node: n });
@@ -51,15 +52,15 @@ impl PatchVerification for InlineDFG {
     }
 }
 
-impl PatchHugrMut for InlineDFG {
+impl<N: HugrNode> PatchHugrMut for InlineDFG<N> {
     /// The removed nodes: the DFG, and its Input and Output children.
-    type Outcome = [Node; 3];
+    type Outcome = [N; 3];
 
     const UNCHANGED_ON_FAILURE: bool = true;
 
     fn apply_hugr_mut(
         self,
-        h: &mut impl crate::hugr::HugrMut<Node = Node>,
+        h: &mut impl crate::hugr::HugrMut<Node = N>,
     ) -> Result<Self::Outcome, Self::Error> {
         self.verify(h)?;
         let n = self.0.node();

hugr-core/src/ops/tag.rs

@@ -9,7 +9,7 @@ use std::{cmp, fmt::Display};
 ///
 /// Uses a flat representation for all the variants, in contrast to the complex
 /// `OpType` structures.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Default)]
 #[non_exhaustive]
 pub enum OpTag {
     /// All operations allowed.

hugr-passes/src/lib.rs

@@ -17,10 +17,17 @@ pub use inline_funcs::inline_acyclic;
 pub mod linearize_array;
 pub use linearize_array::LinearizeArrayPass;
 pub mod lower;
-pub mod merge_bbs;
 mod monomorphize;
+pub mod normalize_cfg;
 pub mod untuple;
 
+/// Merge basic blocks. Subset of [normalize_cfg], use the latter.
+#[deprecated(note = "Use normalize_cfg", since = "0.15.1")]
+pub mod merge_bbs {
+    #[expect(deprecated)] // remove this
+    pub use super::normalize_cfg::merge_basic_blocks;
+}
+
 pub use monomorphize::{MonomorphizePass, mangle_name, monomorphize};
 pub mod replace_types;
 pub use replace_types::ReplaceTypes;