feat!: HugrView API improvements

Cargo.toml

@@ -50,6 +50,7 @@ petgraph = { version = "0.6.3", default-features = false }
 context-iterators = "0.2.0"
 serde_json = "1.0.97"
 delegate = "0.10.0"
+rustversion = "1.0.14"
 
 [features]
 pyo3 = ["dep:pyo3"]

src/builder/build_traits.rs

@@ -236,7 +236,7 @@ pub trait Dataflow: Container {
         hugr: Hugr,
         input_wires: impl IntoIterator<Item = Wire>,
     ) -> Result<BuildHandle<DataflowOpID>, BuildError> {
-        let num_outputs = hugr.get_optype(hugr.root()).signature().output_count();
+        let num_outputs = hugr.get_optype(hugr.root()).value_output_count();
         let node = self.add_hugr(hugr)?.new_root;
 
         let inputs = input_wires.into_iter().collect();
@@ -257,8 +257,8 @@ pub trait Dataflow: Container {
         hugr: &impl HugrView,
         input_wires: impl IntoIterator<Item = Wire>,
     ) -> Result<BuildHandle<DataflowOpID>, BuildError> {
-        let num_outputs = hugr.get_optype(hugr.root()).signature().output_count();
         let node = self.add_hugr_view(hugr)?.new_root;
+        let num_outputs = hugr.get_optype(hugr.root()).value_output_count();
 
         let inputs = input_wires.into_iter().collect();
         wire_up_inputs(inputs, node, self)?;
@@ -612,8 +612,9 @@ pub trait Dataflow: Container {
                 })
             }
         };
-        let const_in_port = signature.output.len();
-        let op_id = self.add_dataflow_op(ops::Call { signature }, input_wires)?;
+        let op: OpType = ops::Call { signature }.into();
+        let const_in_port = op.static_input_port().unwrap();
+        let op_id = self.add_dataflow_op(op, input_wires)?;
         let src_port = self.hugr_mut().num_outputs(function.node()) - 1;
 
         self.hugr_mut()
@@ -633,13 +634,13 @@ fn add_node_with_wires<T: Dataflow + ?Sized>(
     nodetype: impl Into<NodeType>,
     inputs: Vec<Wire>,
 ) -> Result<(Node, usize), BuildError> {
-    let nodetype = nodetype.into();
-    let sig = nodetype.op_signature();
+    let nodetype: NodeType = nodetype.into();
+    let num_outputs = nodetype.op().value_output_count();
     let op_node = data_builder.add_child_node(nodetype)?;
 
     wire_up_inputs(inputs, op_node, data_builder)?;
 
-    Ok((op_node, sig.output().len()))
+    Ok((op_node, num_outputs))
 }
 
 fn wire_up_inputs<T: Dataflow + ?Sized>(

src/builder/conditional.rs

@@ -1,9 +1,10 @@
 use crate::extension::ExtensionRegistry;
 use crate::hugr::views::HugrView;
+use crate::ops::dataflow::DataflowOpTrait;
 use crate::types::{FunctionType, TypeRow};
 
+use crate::ops;
 use crate::ops::handle::CaseID;
-use crate::ops::{self, OpTrait};
 
 use super::build_traits::SubContainer;
 use super::handle::BuildHandle;
@@ -104,12 +105,12 @@ impl<B: AsMut<Hugr> + AsRef<Hugr>> ConditionalBuilder<B> {
     pub fn case_builder(&mut self, case: usize) -> Result<CaseBuilder<&mut Hugr>, BuildError> {
         let conditional = self.conditional_node;
         let control_op = self.hugr().get_optype(self.conditional_node);
-        let extension_delta = control_op.signature().extension_reqs;
 
         let cond: ops::Conditional = control_op
             .clone()
             .try_into()
             .expect("Parent node does not have Conditional optype.");
+        let extension_delta = cond.dataflow_signature().extension_reqs;
         let inputs = cond
             .case_input_row(case)
             .ok_or(ConditionalBuildError::NotCase { conditional, case })?;

src/builder/module.rs

@@ -233,14 +233,14 @@ mod test {
 
             let mut f_build = module_builder.define_function(
                 "main",
-                FunctionType::new(type_row![NAT], type_row![NAT]).pure(),
+                FunctionType::new(type_row![NAT], type_row![NAT, NAT]).pure(),
             )?;
             let local_build = f_build.define_function(
                 "local",
-                FunctionType::new(type_row![NAT], type_row![NAT]).pure(),
+                FunctionType::new(type_row![NAT], type_row![NAT, NAT]).pure(),
             )?;
             let [wire] = local_build.input_wires_arr();
-            let f_id = local_build.finish_with_outputs([wire])?;
+            let f_id = local_build.finish_with_outputs([wire, wire])?;
 
             let call = f_build.call(f_id.handle(), f_build.input_wires())?;
 

src/extension/infer.rs

@@ -305,11 +305,15 @@ impl UnificationContext {
             match node_type.signature() {
                 // Input extensions are open
                 None => {
-                    let delta = node_type.op_signature().extension_reqs;
-                    let c = if delta.is_empty() {
-                        Constraint::Equal(m_input)
+                    let c = if let Some(sig) = node_type.op_signature() {
+                        let delta = sig.extension_reqs;
+                        if delta.is_empty() {
+                            Constraint::Equal(m_input)
+                        } else {
+                            Constraint::Plus(delta, m_input)
+                        }
                     } else {
-                        Constraint::Plus(delta, m_input)
+                        Constraint::Equal(m_input)
                     };
                     self.add_constraint(m_output, c);
                 }
@@ -1063,7 +1067,7 @@ mod test {
                 hugr,
                 conditional_node,
                 op.clone(),
-                Into::<OpType>::into(op).signature(),
+                Into::<OpType>::into(op).signature().unwrap(),
             )?;
 
             let lift1 = hugr.add_node_with_parent(

src/extension/validate.rs

@@ -25,8 +25,13 @@ impl ExtensionValidator {
     pub fn new(hugr: &Hugr, closure: ExtensionSolution) -> Self {
         let mut extensions: HashMap<(Node, Direction), ExtensionSet> = HashMap::new();
         for (node, incoming_sol) in closure.into_iter() {
-            let op_signature = hugr.get_nodetype(node).op_signature();
-            let outgoing_sol = op_signature.extension_reqs.union(&incoming_sol);
+            let extension_reqs = hugr
+                .get_nodetype(node)
+                .op_signature()
+                .map(|s| s.extension_reqs)
+                .unwrap_or_default();
+
+            let outgoing_sol = extension_reqs.union(&incoming_sol);
 
             extensions.insert((node, Direction::Incoming), incoming_sol);
             extensions.insert((node, Direction::Outgoing), outgoing_sol);

src/hugr.rs

@@ -111,13 +111,16 @@ impl NodeType {
 
     /// Use the input extensions to calculate the concrete signature of the node
     pub fn signature(&self) -> Option<Signature> {
-        self.input_extensions
-            .as_ref()
-            .map(|rs| self.op.signature().with_input_extensions(rs.clone()))
+        self.input_extensions.as_ref().map(|rs| {
+            self.op
+                .signature()
+                .unwrap_or_default()
+                .with_input_extensions(rs.clone())
+        })
     }
 
     /// Get the function type from the embedded op
-    pub fn op_signature(&self) -> FunctionType {
+    pub fn op_signature(&self) -> Option<FunctionType> {
         self.op.signature()
     }
 

src/hugr/hugrmut.rs

@@ -314,12 +314,12 @@ impl<T: RootTagged<RootHandle = Node> + AsMut<Hugr>> HugrMut for T {
     ) -> Result<(OutgoingPort, IncomingPort), HugrError> {
         let src_port = self
             .get_optype(src)
-            .other_port_index(Direction::Outgoing)
+            .other_output_port()
             .expect("Source operation has no non-dataflow outgoing edges")
             .as_outgoing()?;
         let dst_port = self
             .get_optype(dst)
-            .other_port_index(Direction::Incoming)
+            .other_input_port()
             .expect("Destination operation has no non-dataflow incoming edges")
             .as_incoming()?;
         self.connect(src, src_port, dst, dst_port)?;

src/hugr/rewrite/insert_identity.rs

@@ -9,7 +9,6 @@ use crate::{HugrView, IncomingPort};
 
 use super::Rewrite;
 
-use itertools::Itertools;
 use thiserror::Error;
 
 /// Specification of a identity-insertion operation.
@@ -73,9 +72,7 @@ impl Rewrite for IdentityInsertion {
         };
 
         let (pre_node, pre_port) = h
-            .linked_outputs(self.post_node, self.post_port)
-            .exactly_one()
-            .ok()
+            .single_source(self.post_node, self.post_port)
             .expect("Value kind input can only have one connection.");
 
         h.disconnect(self.post_node, self.post_port).unwrap();

src/hugr/rewrite/outline_cfg.rs

@@ -70,7 +70,8 @@ impl OutlineCfg {
                     }
                 }
             }
-            extension_delta = extension_delta.union(&o.signature().extension_reqs);
+            extension_delta = extension_delta
+                .union(&o.signature().expect("cfg missing signature").extension_reqs);
             let external_succs = h.output_neighbours(n).filter(|s| !self.blocks.contains(s));
             match external_succs.at_most_one() {
                 Ok(None) => (), // No external successors
@@ -177,7 +178,7 @@ impl Rewrite for OutlineCfg {
         let exit_port = h
             .node_outputs(exit)
             .filter(|p| {
-                let (t, p2) = h.linked_ports(exit, *p).exactly_one().ok().unwrap();
+                let (t, p2) = h.single_target(exit, *p).unwrap();
                 assert!(p2.index() == 0);
                 t == outside
             })

src/hugr/rewrite/replace.rs

@@ -139,9 +139,8 @@ impl NewEdgeSpec {
                 true
             };
             let found_incoming = h
-                .linked_ports(self.tgt, tgt_pos)
-                .exactly_one()
-                .is_ok_and(|(src_n, _)| descends_from_legal(src_n));
+                .single_source(self.tgt, tgt_pos)
+                .is_some_and(|(src_n, _)| descends_from_legal(src_n));
             if !found_incoming {
                 return Err(ReplaceError::NoRemovedEdge(err_edge()));
             };
@@ -617,7 +616,7 @@ mod test {
         entry: bool,
     ) -> Result<BasicBlockID, BuildError> {
         let op: OpType = op.into();
-        let op_sig = op.signature();
+        let op_sig = op.signature().expect("dataflow op needs signature");
         let mut bb = if entry {
             assert_eq!(
                 match h.hugr().get_optype(h.container_node()) {

src/hugr/rewrite/simple_replace.rs

@@ -4,8 +4,6 @@ use std::collections::{hash_map, HashMap};
 use std::iter::{self, Copied};
 use std::slice;
 
-use itertools::Itertools;
-
 use crate::hugr::views::SiblingSubgraph;
 use crate::hugr::{HugrMut, HugrView, NodeMetadataMap, Rewrite};
 use crate::ops::{OpTag, OpTrait, OpType};
@@ -129,11 +127,8 @@ impl Rewrite for SimpleReplacement {
         for ((rep_inp_node, rep_inp_port), (rem_inp_node, rem_inp_port)) in &self.nu_inp {
             if self.replacement.get_optype(*rep_inp_node).tag() != OpTag::Output {
                 // add edge from predecessor of (s_inp_node, s_inp_port) to (new_inp_node, n_inp_port)
-                let (rem_inp_pred_node, rem_inp_pred_port) = h
-                    .linked_outputs(*rem_inp_node, *rem_inp_port)
-                    .exactly_one()
-                    .ok() // PortLinks does not implement Debug
-                    .unwrap();
+                let (rem_inp_pred_node, rem_inp_pred_port) =
+                    h.single_source(*rem_inp_node, *rem_inp_port).unwrap();
                 h.disconnect(*rem_inp_node, *rem_inp_port).unwrap();
                 let new_inp_node = index_map.get(rep_inp_node).unwrap();
                 h.connect(
@@ -150,8 +145,7 @@ impl Rewrite for SimpleReplacement {
         for ((rem_out_node, rem_out_port), rep_out_port) in &self.nu_out {
             let (rep_out_pred_node, rep_out_pred_port) = self
                 .replacement
-                .linked_outputs(replacement_output_node, *rep_out_port)
-                .exactly_one()
+                .single_source(replacement_output_node, *rep_out_port)
                 .unwrap();
             if self.replacement.get_optype(rep_out_pred_node).tag() != OpTag::Input {
                 let new_out_node = index_map.get(&rep_out_pred_node).unwrap();
@@ -171,11 +165,8 @@ impl Rewrite for SimpleReplacement {
             let rem_inp_nodeport = self.nu_inp.get(&(replacement_output_node, rep_out_port));
             if let Some((rem_inp_node, rem_inp_port)) = rem_inp_nodeport {
                 // add edge from predecessor of (rem_inp_node, rem_inp_port) to (rem_out_node, rem_out_port):
-                let (rem_inp_pred_node, rem_inp_pred_port) = h
-                    .linked_outputs(*rem_inp_node, *rem_inp_port)
-                    .exactly_one()
-                    .ok() // PortLinks does not implement Debug
-                    .unwrap();
+                let (rem_inp_pred_node, rem_inp_pred_port) =
+                    h.single_source(*rem_inp_node, *rem_inp_port).unwrap();
                 h.disconnect(*rem_inp_node, *rem_inp_port).unwrap();
                 h.disconnect(*rem_out_node, *rem_out_port).unwrap();
                 h.connect(
@@ -505,15 +496,27 @@ pub(in crate::hugr::rewrite) mod test {
             .collect_vec();
         let inputs = h
             .node_outputs(input)
-            .filter(|&p| h.get_optype(input).signature().get(p).is_some())
+            .filter(|&p| {
+                h.get_optype(input)
+                    .signature()
+                    .unwrap()
+                    .port_type(p)
+                    .is_some()
+            })
             .map(|p| {
                 let link = h.linked_inputs(input, p).next().unwrap();
                 (link, link)
             })
             .collect();
         let outputs = h
             .node_inputs(output)
-            .filter(|&p| h.get_optype(output).signature().get(p).is_some())
+            .filter(|&p| {
+                h.get_optype(output)
+                    .signature()
+                    .unwrap()
+                    .port_type(p)
+                    .is_some()
+            })
             .map(|p| ((output, p), p))
             .collect();
         h.apply_rewrite(SimpleReplacement::new(
@@ -565,7 +568,7 @@ pub(in crate::hugr::rewrite) mod test {
 
         let outputs = repl
             .node_inputs(repl_output)
-            .filter(|&p| repl.get_optype(repl_output).signature().get(p).is_some())
+            .filter(|&p| repl.signature(repl_output).unwrap().port_type(p).is_some())
             .map(|p| ((repl_output, p), p))
             .collect();
 
@@ -598,7 +601,7 @@ pub(in crate::hugr::rewrite) mod test {
                 if *tgt == out {
                     unimplemented!()
                 };
-                let (src, src_port) = h.linked_outputs(*r_n, *r_p).exactly_one().ok().unwrap();
+                let (src, src_port) = h.single_source(*r_n, *r_p).unwrap();
                 NewEdgeSpec {
                     src,
                     tgt: *tgt,
@@ -613,11 +616,7 @@ pub(in crate::hugr::rewrite) mod test {
             .nu_out
             .iter()
             .map(|((tgt, tgt_port), out_port)| {
-                let (src, src_port) = replacement
-                    .linked_outputs(out, *out_port)
-                    .exactly_one()
-                    .ok()
-                    .unwrap();
+                let (src, src_port) = replacement.single_source(out, *out_port).unwrap();
                 if src == in_ {
                     unimplemented!()
                 };

src/hugr/serialize.rs

@@ -10,7 +10,6 @@ use pyo3::{create_exception, exceptions::PyException, PyErr};
 use crate::core::NodeIndex;
 use crate::extension::ExtensionSet;
 use crate::hugr::{Hugr, NodeType};
-use crate::ops::OpTrait;
 use crate::ops::OpType;
 use crate::{Node, PortIndex};
 use portgraph::hierarchy::AttachError;
@@ -167,7 +166,7 @@ impl TryFrom<&Hugr> for SerHugrV0 {
             .expect("Could not reach one of the nodes");
 
         let find_offset = |node: Node, offset: usize, dir: Direction, hugr: &Hugr| {
-            let sig = hugr.get_optype(node).signature();
+            let sig = hugr.signature(node).unwrap_or_default();
             let offset = match offset < sig.port_count(dir) {
                 true => Some(offset as u16),
                 false => None,
@@ -246,7 +245,7 @@ impl TryFrom<SerHugrV0> for Hugr {
                 None => {
                     let op_type = hugr.get_optype(node);
                     op_type
-                        .other_port_index(dir)
+                        .other_port(dir)
                         .ok_or(HUGRSerializationError::MissingPortOffset {
                             node,
                             op_type: op_type.clone(),

src/hugr/validate/test.rs

@@ -428,8 +428,10 @@ fn test_local_const() -> Result<(), HugrError> {
     // Second input of Xor from a constant
     let cst = h.add_node_with_parent(h.root(), const_op)?;
     let lcst = h.add_node_with_parent(h.root(), ops::LoadConstant { datatype: BOOL_T })?;
+
     h.connect(cst, 0, lcst, 0)?;
     h.connect(lcst, 0, and, 1)?;
+    assert_eq!(h.static_source(lcst), Some(cst));
     // There is no edge from Input to LoadConstant, but that's OK:
     h.update_validate(&EMPTY_REG).unwrap();
     Ok(())