Merge branch 'main' into lm/emptycommit

Author: lmondada

.github/workflows/ci-py.yml

@@ -191,7 +191,7 @@ jobs:
           fetch-depth: 0  # Need full history to compare with main
 
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10'
 

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    "hugr-py": "0.12.4"
+    "hugr-py": "0.12.5"
 }

Cargo.toml

@@ -38,10 +38,6 @@ missing_docs = "warn"
 # https://github.com/rust-lang/rust-clippy/issues/5112
 debug_assert_with_mut_call = "warn"
 
-# TODO: Reduce the size of error types.
-result_large_err = "allow"
-large_enum_variant = "allow"
-
 [workspace.dependencies]
 anyhow = "1.0.98"
 insta = { version = "1.43.1" }

hugr-core/src/builder.rs

@@ -189,7 +189,7 @@ pub enum BuildError {
     #[error("Found an error while setting the outputs of a {} container, {container_node}. {error}", .container_op.name())]
     #[allow(missing_docs)]
     OutputWiring {
-        container_op: OpType,
+        container_op: Box<OpType>,
         container_node: Node,
         #[source]
         error: BuilderWiringError,
@@ -201,7 +201,7 @@ pub enum BuildError {
     #[error("Got an input wire while adding a {} to the circuit. {error}", .op.name())]
     #[allow(missing_docs)]
     OperationWiring {
-        op: OpType,
+        op: Box<OpType>,
         #[source]
         error: BuilderWiringError,
     },
@@ -219,7 +219,7 @@ pub enum BuilderWiringError {
     #[error("Cannot copy linear type {typ} from output {src_offset} of node {src}")]
     #[allow(missing_docs)]
     NoCopyLinear {
-        typ: Type,
+        typ: Box<Type>,
         src: Node,
         src_offset: Port,
     },
@@ -244,7 +244,7 @@ pub enum BuilderWiringError {
         src_offset: Port,
         dst: Node,
         dst_offset: Port,
-        typ: Type,
+        typ: Box<Type>,
     },
 }
 

hugr-core/src/builder/build_traits.rs

@@ -213,8 +213,10 @@ pub trait Dataflow: Container {
         let num_outputs = optype.value_output_count();
         let node = self.add_hugr(hugr).inserted_entrypoint;
 
-        wire_up_inputs(input_wires, node, self)
-            .map_err(|error| BuildError::OperationWiring { op: optype, error })?;
+        wire_up_inputs(input_wires, node, self).map_err(|error| BuildError::OperationWiring {
+            op: Box::new(optype),
+            error,
+        })?;
 
         Ok((node, num_outputs).into())
     }
@@ -235,8 +237,10 @@ pub trait Dataflow: Container {
         let optype = hugr.get_optype(hugr.entrypoint()).clone();
         let num_outputs = optype.value_output_count();
 
-        wire_up_inputs(input_wires, node, self)
-            .map_err(|error| BuildError::OperationWiring { op: optype, error })?;
+        wire_up_inputs(input_wires, node, self).map_err(|error| BuildError::OperationWiring {
+            op: Box::new(optype),
+            error,
+        })?;
 
         Ok((node, num_outputs).into())
     }
@@ -253,7 +257,7 @@ pub trait Dataflow: Container {
         let [_, out] = self.io();
         wire_up_inputs(output_wires.into_iter().collect_vec(), out, self).map_err(|error| {
             BuildError::OutputWiring {
-                container_op: self.hugr().get_optype(self.container_node()).clone(),
+                container_op: Box::new(self.hugr().get_optype(self.container_node()).clone()),
                 container_node: self.container_node(),
                 error,
             }
@@ -662,8 +666,10 @@ fn add_node_with_wires<T: Dataflow + ?Sized>(
     let num_outputs = op.value_output_count();
     let op_node = data_builder.add_child_node(op.clone());
 
-    wire_up_inputs(inputs, op_node, data_builder)
-        .map_err(|error| BuildError::OperationWiring { op, error })?;
+    wire_up_inputs(inputs, op_node, data_builder).map_err(|error| BuildError::OperationWiring {
+        op: Box::new(op),
+        error,
+    })?;
 
     Ok((op_node, num_outputs))
 }
@@ -715,7 +721,7 @@ fn wire_up<T: Dataflow + ?Sized>(
                     src_offset: src_port.into(),
                     dst,
                     dst_offset: dst_port.into(),
-                    typ,
+                    typ: Box::new(typ),
                 });
             }
 
@@ -746,7 +752,7 @@ fn wire_up<T: Dataflow + ?Sized>(
         } else if !typ.copyable() & base.linked_ports(src, src_port).next().is_some() {
             // Don't copy linear edges.
             return Err(BuilderWiringError::NoCopyLinear {
-                typ,
+                typ: Box::new(typ),
                 src,
                 src_offset: src_port.into(),
             });

hugr-core/src/builder/circuit.rs

@@ -27,18 +27,18 @@ pub struct CircuitBuilder<'a, T: ?Sized> {
 #[non_exhaustive]
 pub enum CircuitBuildError {
     /// Invalid index for stored wires.
-    #[error("Invalid wire index {invalid_index} while attempting to add operation {}.", .op.as_ref().map(NamedOp::name).unwrap_or_default())]
+    #[error("Invalid wire index {invalid_index} while attempting to add operation {}.", .op.as_ref().map(|op| op.name()).unwrap_or_default())]
     InvalidWireIndex {
         /// The operation.
-        op: Option<OpType>,
+        op: Option<Box<OpType>>,
         /// The invalid indices.
         invalid_index: usize,
     },
     /// Some linear inputs had no corresponding output wire.
     #[error("The linear inputs {:?} had no corresponding output wire in operation {}.", .index.as_slice(), .op.name())]
     MismatchedLinearInputs {
         /// The operation.
-        op: OpType,
+        op: Box<OpType>,
         /// The index of the input that had no corresponding output wire.
         index: Vec<usize>,
     },
@@ -143,7 +143,7 @@ impl<'a, T: Dataflow + ?Sized> CircuitBuilder<'a, T> {
 
         let input_wires =
             input_wires.map_err(|invalid_index| CircuitBuildError::InvalidWireIndex {
-                op: Some(op.clone()),
+                op: Some(Box::new(op.clone())),
                 invalid_index,
             })?;
 
@@ -169,7 +169,7 @@ impl<'a, T: Dataflow + ?Sized> CircuitBuilder<'a, T> {
 
         if !linear_inputs.is_empty() {
             return Err(CircuitBuildError::MismatchedLinearInputs {
-                op,
+                op: Box::new(op),
                 index: linear_inputs.values().copied().collect(),
             }
             .into());
@@ -389,7 +389,7 @@ mod test {
                 assert_matches!(
                     circ.append(cx_gate(), [q0, invalid_index]),
                     Err(BuildError::CircuitError(CircuitBuildError::InvalidWireIndex { op, invalid_index: idx }))
-                    if op == Some(cx_gate().into()) && idx == invalid_index,
+                    if op == Some(Box::new(cx_gate().into())) && idx == invalid_index,
                 );
 
                 // Untracking an invalid index returns an error
@@ -403,7 +403,7 @@ mod test {
                 assert_matches!(
                     circ.append(q_discard(), [q1]),
                     Err(BuildError::CircuitError(CircuitBuildError::MismatchedLinearInputs { op, index }))
-                    if op == q_discard().into() && index == [q1],
+                    if *op == q_discard().into() && index == [q1],
                 );
 
                 let outs = circ.finish();

hugr-core/src/builder/dataflow.rs

@@ -8,14 +8,9 @@ use std::marker::PhantomData;
 
 use crate::hugr::internal::HugrMutInternals;
 use crate::hugr::{HugrView, ValidationError};
-use crate::ops::{self, OpParent};
-use crate::ops::{DataflowParent, Input, Output};
-use crate::{Direction, IncomingPort, OutgoingPort, Wire};
-
+use crate::ops::{self, DataflowParent, FuncDefn, Input, OpParent, Output};
 use crate::types::{PolyFuncType, Signature, Type};
-
-use crate::Node;
-use crate::{Hugr, hugr::HugrMut};
+use crate::{Direction, Hugr, IncomingPort, Node, OutgoingPort, Visibility, Wire, hugr::HugrMut};
 
 /// Builder for a [`ops::DFG`] node.
 #[derive(Debug, Clone, PartialEq)]
@@ -152,17 +147,35 @@ impl<B, T> DFGWrapper<B, T> {
 pub type FunctionBuilder<B> = DFGWrapper<B, BuildHandle<FuncID<true>>>;
 
 impl FunctionBuilder<Hugr> {
-    /// Initialize a builder for a `FuncDefn` rooted HUGR
+    /// Initialize a builder for a [`FuncDefn`](ops::FuncDefn)-rooted HUGR;
+    /// the function will be private. (See also [Self::new_vis].)
+    ///
     /// # Errors
     ///
     /// Error in adding DFG child nodes.
     pub fn new(
         name: impl Into<String>,
         signature: impl Into<PolyFuncType>,
     ) -> Result<Self, BuildError> {
-        let signature: PolyFuncType = signature.into();
-        let body = signature.body().clone();
-        let op = ops::FuncDefn::new(name, signature);
+        Self::new_with_op(FuncDefn::new(name, signature))
+    }
+
+    /// Initialize a builder for a FuncDefn-rooted HUGR, with the specified
+    /// [Visibility].
+    ///
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
+    pub fn new_vis(
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+        visibility: Visibility,
+    ) -> Result<Self, BuildError> {
+        Self::new_with_op(FuncDefn::new_vis(name, signature, visibility))
+    }
+
+    fn new_with_op(op: FuncDefn) -> Result<Self, BuildError> {
+        let body = op.signature().body().clone();
 
         let base = Hugr::new_with_entrypoint(op).expect("FuncDefn entrypoint should be valid");
         let root = base.entrypoint();
@@ -437,7 +450,7 @@ pub(crate) mod test {
                 error: BuilderWiringError::NoCopyLinear { typ, .. },
                 ..
             })
-            if typ == qb_t()
+            if *typ == qb_t()
         );
     }