Merge 'origin/main' into new/replace, update add_{op=>node}_...

.github/workflows/ci.yml

@@ -82,11 +82,11 @@ jobs:
         with:
           prefix-key: v0-rust-${{ matrix.rust }}
       - name: Build with no features
-        run: cargo build --verbose --no-default-features
-      - name: Build with all features
-        run: cargo build --verbose --all-features
+        run: cargo test --verbose --no-default-features --no-run
       - name: Tests with no features
         run: cargo test --verbose --no-default-features
+      - name: Build with all features
+        run: cargo test --verbose --all-features --no-run
       - name: Tests with all features
         run: cargo test --verbose --all-features
 

.github/workflows/coverage.yml → .github/workflows/notify-coverage.yml

@@ -1,4 +1,8 @@
-name: Coverage
+name: Notify coverage changes
+
+# Daily notification for coverage changes in `main`.
+#
+# PR coverage diffs are computed directly in the `Continuous Integration` workflow.
 
 on:
   schedule:

src/builder.rs

@@ -149,14 +149,14 @@ pub(crate) mod test {
         let mut hugr = Hugr::new(NodeType::new_pure(ops::DFG {
             signature: signature.clone(),
         }));
-        hugr.add_op_with_parent(
+        hugr.add_node_with_parent(
             hugr.root(),
             ops::Input {
                 types: signature.input,
             },
         )
         .unwrap();
-        hugr.add_op_with_parent(
+        hugr.add_node_with_parent(
             hugr.root(),
             ops::Output {
                 types: signature.output,

src/builder/build_traits.rs

@@ -47,7 +47,7 @@ pub trait Container {
     /// Add an [`OpType`] as the final child of the container.
     fn add_child_op(&mut self, op: impl Into<OpType>) -> Result<Node, BuildError> {
         let parent = self.container_node();
-        Ok(self.hugr_mut().add_op_with_parent(parent, op)?)
+        Ok(self.hugr_mut().add_node_with_parent(parent, op)?)
     }
     /// Add a [`NodeType`] as the final child of the container.
     fn add_child_node(&mut self, node: NodeType) -> Result<Node, BuildError> {
@@ -416,7 +416,7 @@ pub trait Dataflow: Container {
             rest: rest_types.into(),
         };
         // TODO: Make input extensions a parameter
-        let (loop_node, _) = add_op_with_wires(self, tail_loop.clone(), input_wires)?;
+        let (loop_node, _) = add_node_with_wires(self, tail_loop.clone(), input_wires)?;
 
         TailLoopBuilder::create_with_io(self.hugr_mut(), loop_node, &tail_loop)
     }
@@ -623,21 +623,14 @@ pub trait Dataflow: Container {
     }
 }
 
-fn add_op_with_wires<T: Dataflow + ?Sized>(
-    data_builder: &mut T,
-    optype: impl Into<OpType>,
-    inputs: Vec<Wire>,
-) -> Result<(Node, usize), BuildError> {
-    add_node_with_wires(data_builder, NodeType::new_auto(optype), inputs)
-}
-
 fn add_node_with_wires<T: Dataflow + ?Sized>(
     data_builder: &mut T,
-    nodetype: NodeType,
+    nodetype: impl Into<NodeType>,
     inputs: Vec<Wire>,
 ) -> Result<(Node, usize), BuildError> {
-    let op_node = data_builder.add_child_node(nodetype.clone())?;
+    let nodetype = nodetype.into();
     let sig = nodetype.op_signature();
+    let op_node = data_builder.add_child_node(nodetype)?;
 
     wire_up_inputs(inputs, op_node, data_builder)?;
 

src/builder/cfg.rs

@@ -92,7 +92,7 @@ impl<B: AsMut<Hugr> + AsRef<Hugr>> CFGBuilder<B> {
         let exit_node = base
             .as_mut()
             // Make the extensions a parameter
-            .add_op_with_parent(cfg_node, exit_block_type)?;
+            .add_node_with_parent(cfg_node, exit_block_type)?;
         Ok(Self {
             base,
             cfg_node,
@@ -144,10 +144,10 @@ impl<B: AsMut<Hugr> + AsRef<Hugr>> CFGBuilder<B> {
         let block_n = if entry {
             let exit = self.exit_node;
             // TODO: Make extensions a parameter
-            self.hugr_mut().add_op_before(exit, op)
+            self.hugr_mut().add_node_before(exit, op)
         } else {
             // TODO: Make extensions a parameter
-            self.hugr_mut().add_op_with_parent(parent, op)
+            self.hugr_mut().add_node_with_parent(parent, op)
         }?;
 
         BlockBuilder::create(

src/builder/conditional.rs

@@ -126,7 +126,7 @@ impl<B: AsMut<Hugr> + AsRef<Hugr>> ConditionalBuilder<B> {
         let case_node =
             // add case before any existing subsequent cases
             if let Some(&sibling_node) = self.case_nodes[case + 1..].iter().flatten().next() {
-                self.hugr_mut().add_op_before(sibling_node, case_op)?
+                self.hugr_mut().add_node_before(sibling_node, case_op)?
             } else {
                 self.add_child_op(case_op)?
             };

src/core.rs

@@ -2,7 +2,10 @@
 //!
 //! These types are re-exported in the root of the crate.
 
+pub use itertools::Either;
+
 use derive_more::From;
+use itertools::Either::{Left, Right};
 
 #[cfg(feature = "pyo3")]
 use pyo3::pyclass;
@@ -92,35 +95,32 @@ impl Port {
     /// [HugrError::InvalidPortDirection]
     #[inline]
     pub fn as_incoming(&self) -> Result<IncomingPort, HugrError> {
-        match self.direction() {
-            Direction::Incoming => Ok(IncomingPort {
-                index: self.index() as u16,
-            }),
-            dir @ Direction::Outgoing => Err(HugrError::InvalidPortDirection(dir)),
-        }
+        self.as_directed()
+            .left()
+            .ok_or(HugrError::InvalidPortDirection(self.direction()))
     }
 
     /// Converts to an [OutgoingPort] if this port is one; else fails with
     /// [HugrError::InvalidPortDirection]
     #[inline]
     pub fn as_outgoing(&self) -> Result<OutgoingPort, HugrError> {
+        self.as_directed()
+            .right()
+            .ok_or(HugrError::InvalidPortDirection(self.direction()))
+    }
+
+    /// Converts to either an [IncomingPort] or an [OutgoingPort], as appropriate.
+    #[inline]
+    pub fn as_directed(&self) -> Either<IncomingPort, OutgoingPort> {
         match self.direction() {
-            Direction::Outgoing => Ok(OutgoingPort {
+            Direction::Incoming => Left(IncomingPort {
+                index: self.index() as u16,
+            }),
+            Direction::Outgoing => Right(OutgoingPort {
                 index: self.index() as u16,
             }),
-            dir @ Direction::Incoming => Err(HugrError::InvalidPortDirection(dir)),
         }
     }
-    /// Creates a new outgoing port.
-    #[inline]
-    pub fn try_new_outgoing(port: impl TryInto<OutgoingPort>) -> Result<Self, HugrError> {
-        let Ok(port) = port.try_into() else {
-            return Err(HugrError::InvalidPortDirection(Direction::Incoming));
-        };
-        Ok(Self {
-            offset: portgraph::PortOffset::new_outgoing(port.index()),
-        })
-    }
 
     /// Returns the direction of the port.
     #[inline]