take some clippy pedantic suggestions

mostly docs

Author: ss2165

src/builder.rs

@@ -81,7 +81,7 @@ impl AsRef<HugrMut> for HugrMut {
     }
 }
 
-/// Trait allowing treating type as (im)mutable reference to HugrMut
+/// Trait allowing treating type as (im)mutable reference to [`HugrMut`]
 pub trait HugrMutRef: AsMut<HugrMut> + AsRef<HugrMut> {}
 impl HugrMutRef for HugrMut {}
 impl HugrMutRef for &mut HugrMut {}

src/builder/build_traits.rs

@@ -104,7 +104,7 @@ pub trait Dataflow: Container {
     fn input_wires(&self) -> Outputs {
         self.input().outputs()
     }
-    /// Add a dataflow op to the sibling graph, wiring up the input_wires to the
+    /// Add a dataflow op to the sibling graph, wiring up the `input_wires` to the
     /// incoming ports of the resulting node.
     ///
     /// # Errors
@@ -120,7 +120,7 @@ pub trait Dataflow: Container {
         Ok(outs.into())
     }
 
-    /// Wire up the output_wires to the input ports of the Output node.
+    /// Wire up the `output_wires` to the input ports of the Output node.
     ///
     /// # Errors
     ///
@@ -142,7 +142,7 @@ pub trait Dataflow: Container {
         self.input_wires()
             .collect_vec()
             .try_into()
-            .expect(&format!("Incorrect number of wires: {}", N)[..])
+            .expect(&format!("Incorrect number of wires: {N}")[..])
     }
 
     /// Return a builder for a [`crate::ops::dataflow::DataflowOp::DFG`] node, i.e. a nested dataflow subgraph.
@@ -255,7 +255,7 @@ pub trait Dataflow: Container {
     /// # Errors
     ///
     /// This function will return an error if there is an error when building
-    /// the TailLoop node.
+    /// the [`ControlFlowOp::TailLoop`] node.
     fn tail_loop_builder(
         &mut self,
         just_inputs: impl IntoIterator<Item = (SimpleType, Wire)>,
@@ -279,7 +279,7 @@ pub trait Dataflow: Container {
             input_wires,
         )?;
 
-        TailLoopBuilder::create_with_io(self.base(), loop_node, tail_loop_signature)
+        TailLoopBuilder::create_with_io(self.base(), loop_node, &tail_loop_signature)
     }
 
     /// Return a builder for a [`crate::ops::controlflow::ControlFlowOp::Conditional`] node.
@@ -386,7 +386,7 @@ pub trait Dataflow: Container {
     /// # Errors
     ///
     /// This function will return an error if there is an error adding the
-    /// MakeTuple node.
+    /// [`LeafOp::MakeTuple`] node.
     fn make_tuple(&mut self, values: impl IntoIterator<Item = Wire>) -> Result<Wire, BuildError> {
         let values = values.into_iter().collect_vec();
         let types: Result<Vec<SimpleType>, _> = values
@@ -427,7 +427,7 @@ pub trait Dataflow: Container {
     }
 
     /// Use the wires in `values` to return a wire corresponding to the
-    /// "Continue" variant of a TailLoop with `loop_signature`.
+    /// "Continue" variant of a [`ControlFlowOp::TailLoop`] with `loop_signature`.
     ///
     /// Packs the values in to a tuple and tags appropriately to generate a
     /// value of Sum type.
@@ -448,7 +448,7 @@ pub trait Dataflow: Container {
     }
 
     /// Use the wires in `values` to return a wire corresponding to the
-    /// "Break" variant of a TailLoop with `loop_signature`.
+    /// "Break" variant of a [`ControlFlowOp::TailLoop`] with `loop_signature`.
     ///
     /// Packs the values in to a tuple and tags appropriately to generate a
     /// value of Sum type.

src/builder/cfg.rs

@@ -223,8 +223,9 @@ impl<B: HugrMutRef> BlockBuilder<B> {
     ) -> Result<Self, BuildError> {
         // The node outputs a predicate before the data outputs of the block node
         let predicate_type = SimpleType::new_predicate(predicate_variants);
-        let node_outputs: TypeRow = [&[predicate_type], other_outputs.as_ref()].concat().into();
-        let db = DFGBuilder::create_with_io(base, block_n, inputs, node_outputs)?;
+        let mut node_outputs = vec![predicate_type];
+        node_outputs.extend_from_slice(&other_outputs);
+        let db = DFGBuilder::create_with_io(base, block_n, inputs, node_outputs.into())?;
         Ok(BlockBuilder::from_dfg_builder(db))
     }
 }
@@ -244,7 +245,7 @@ impl BlockBuilder<&mut HugrMut> {
 }
 
 impl BlockBuilder<HugrMut> {
-    /// Initialize a BasicBlock rooted HUGR builder
+    /// Initialize a [`BasicBlockOp::Block`] rooted HUGR builder
     pub fn new(
         inputs: impl Into<TypeRow>,
         predicate_variants: impl IntoIterator<Item = TypeRow>,

src/builder/circuit_builder.rs

@@ -37,21 +37,22 @@ impl From<Wire> for AppendWire {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
-/// Error in CircuitBuilder
+/// Error in [`CircuitBuilder`]
 pub enum CircuitBuildError {
     /// Invalid index for stored wires.
     #[error("Invalid wire index.")]
     InvalidWireIndex,
 }
 
 impl<'a, T: Dataflow + ?Sized> CircuitBuilder<'a, T> {
-    /// Construct a new CircuitBuilder from a vector of incoming wires and the
+    /// Construct a new [`CircuitBuilder`] from a vector of incoming wires and the
     /// builder for the graph
     pub fn new(wires: Vec<Wire>, builder: &'a mut T) -> Self {
         Self { wires, builder }
     }
 
     /// Number of wires tracked, upper bound of valid wire indices
+    #[must_use]
     pub fn n_wires(&self) -> usize {
         self.wires.len()
     }
@@ -184,7 +185,7 @@ mod test {
 
     #[test]
     fn with_nonlinear_and_outputs() {
-        use AppendWire::*;
+        use AppendWire::{I, W};
         let build_res = build_main(
             Signature::new_df(type_row![QB, QB, F64], type_row![QB, QB, BIT]),
             |mut f_build| {

src/builder/dataflow.rs

@@ -50,6 +50,10 @@ impl<T: HugrMutRef> DFGBuilder<T> {
 }
 impl DFGBuilder<HugrMut> {
     /// Begin building a new DFG rooted HUGR.
+    /// 
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
     pub fn new(
         input: impl Into<TypeRow>,
         output: impl Into<TypeRow>,
@@ -123,6 +127,9 @@ pub type FunctionBuilder<B> = DFGWrapper<B, BuildHandle<FuncID<true>>>;
 
 impl FunctionBuilder<HugrMut> {
     /// Initialize a builder for a Def rooted HUGR
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
     pub fn new(_name: impl Into<String>, signature: Signature) -> Result<Self, BuildError> {
         let inputs = signature.input.clone();
         let outputs = signature.output.clone();

src/builder/module_builder.rs

@@ -40,6 +40,7 @@ impl<T: HugrMutRef> Container for ModuleBuilder<T> {
 
 impl ModuleBuilder<HugrMut> {
     /// Begin building a new module.
+    #[must_use]
     pub fn new() -> Self {
         Self(HugrMut::new_module())
     }
@@ -101,10 +102,10 @@ impl<T: HugrMutRef> ModuleBuilder<T> {
     /// [`ModuleOp::Def`] node.
     pub fn declare_and_def(
         &mut self,
-        _name: impl Into<String>,
+        name: impl Into<String>,
         signature: Signature,
     ) -> Result<FunctionBuilder<&mut HugrMut>, BuildError> {
-        let fid = self.declare(_name, signature)?;
+        let fid = self.declare(name, signature)?;
         self.define_function(&fid)
     }
 
@@ -126,6 +127,10 @@ impl<T: HugrMutRef> ModuleBuilder<T> {
     }
 
     /// Add a [`ModuleOp::AliasDef`] node and return a handle to the Alias.
+    ///
+    /// # Errors
+    ///
+    /// Error in adding [`ModuleOp::AliasDef`] child node.
     pub fn add_alias_def(
         &mut self,
         name: impl Into<SmolStr>,
@@ -142,6 +147,9 @@ impl<T: HugrMutRef> ModuleBuilder<T> {
     }
 
     /// Add a [`ModuleOp::AliasDeclare`] node and return a handle to the Alias.
+    /// # Errors
+    ///
+    /// Error in adding [`ModuleOp::AliasDeclare`] child node.
     pub fn add_alias_declare(
         &mut self,
         name: impl Into<SmolStr>,

src/builder/tail_loop.rs

@@ -21,7 +21,7 @@ impl<B: HugrMutRef> TailLoopBuilder<B> {
     pub(super) fn create_with_io(
         base: B,
         loop_node: Node,
-        tail_loop_sig: TailLoopSignature,
+        tail_loop_sig: &TailLoopSignature,
     ) -> Result<Self, BuildError> {
         let dfg_build = DFGBuilder::create_with_io(
             base,
@@ -32,7 +32,7 @@ impl<B: HugrMutRef> TailLoopBuilder<B> {
 
         Ok(TailLoopBuilder::from_dfg_builder(dfg_build))
     }
-    /// Set the outputs of the TailLoop, with `out_variant` as the value of the
+    /// Set the outputs of the [`ControlFlowOp::TailLoop`], with `out_variant` as the value of the
     /// termination predicate, and `rest` being the remaining outputs
     pub fn set_outputs(
         &mut self,
@@ -43,7 +43,7 @@ impl<B: HugrMutRef> TailLoopBuilder<B> {
     }
 
     /// Get a reference to the [`crate::ops::controlflow::TailLoopSignature`]
-    /// that defines the signature of the TailLoop
+    /// that defines the signature of the [`ControlFlowOp::TailLoop`]
     pub fn loop_signature(&self) -> Result<&TailLoopSignature, BuildError> {
         if let OpType::Dataflow(DataflowOp::ControlFlow {
             op: ControlFlowOp::TailLoop(tail_sig),
@@ -81,7 +81,7 @@ impl TailLoopBuilder<&mut HugrMut> {
 }
 
 impl TailLoopBuilder<HugrMut> {
-    /// Initialize new builder for a TailLoop rooted HUGR
+    /// Initialize new builder for a [`ControlFlowOp::TailLoop`] rooted HUGR
     pub fn new(
         just_inputs: impl Into<TypeRow>,
         inputs_outputs: impl Into<TypeRow>,
@@ -95,7 +95,7 @@ impl TailLoopBuilder<HugrMut> {
         let op = ControlFlowOp::TailLoop(tail_loop_sig.clone());
         let base = HugrMut::new(op);
         let root = base.hugr().root();
-        Self::create_with_io(base, root, tail_loop_sig)
+        Self::create_with_io(base, root, &tail_loop_sig)
     }
 }