WIP start removing NodeType

hugr-core/src/builder/build_traits.rs

@@ -348,9 +348,8 @@ pub trait Dataflow: Container {
     /// Adds a [`OpType::LoadConstant`] node.
     fn load_const(&mut self, cid: &ConstID) -> Wire {
         let const_node = cid.node();
-        let nodetype = self.hugr().get_nodetype(const_node);
-        let op: ops::Const = nodetype
-            .op()
+        let optype = self.hugr().get_optype(const_node);
+        let op: ops::Const = optype
             .clone()
             .try_into()
             .expect("ConstID does not refer to Const op.");

hugr-core/src/hugr.rs

@@ -49,7 +49,7 @@ pub struct Hugr {
     root: portgraph::NodeIndex,
 
     /// Operation types for each node.
-    op_types: UnmanagedDenseMap<portgraph::NodeIndex, NodeType>,
+    op_types: UnmanagedDenseMap<portgraph::NodeIndex, OpType>,
 
     /// Node metadata
     metadata: UnmanagedDenseMap<portgraph::NodeIndex, Option<NodeMetadataMap>>,
@@ -402,11 +402,12 @@ mod test {
         hugr.connect(lift, 0, output, 0);
         hugr.infer_extensions()?;
 
-        assert_eq!(
-            hugr.get_nodetype(lift).input_extensions().unwrap(),
-            &ExtensionSet::new()
-        );
-        assert_eq!(hugr.get_nodetype(output).input_extensions().unwrap(), &r);
-        Ok(())
+// ALAN do something here? Check it doesn't work if we don't express the correct delta for the function?
+//      assert_eq!(
+//          hugr.get_nodetype(lift).input_extensions().unwrap(),
+//          &ExtensionSet::new()
+//      );
+//      assert_eq!(hugr.get_nodetype(output).input_extensions().unwrap(), &r);
+//      Ok(())
     }
 }

hugr-core/src/hugr/hugrmut.rs

@@ -341,8 +341,8 @@ impl<T: RootTagged<RootHandle = Node> + AsMut<Hugr>> HugrMut for T {
         let (new_root, node_map) = insert_hugr_internal(self.as_mut(), root, other);
         // Update the optypes and metadata, copying them from the other graph.
         for (&node, &new_node) in node_map.iter() {
-            let nodetype = other.get_nodetype(node.into());
-            self.as_mut().op_types.set(new_node, nodetype.clone());
+            let optype = other.get_optype(node.into());
+            self.as_mut().op_types.set(new_node, optype.clone());
             let meta = other.base_hugr().metadata.get(node);
             self.as_mut().metadata.set(new_node, meta.clone());
         }
@@ -372,8 +372,8 @@ impl<T: RootTagged<RootHandle = Node> + AsMut<Hugr>> HugrMut for T {
         let node_map = insert_subgraph_internal(self.as_mut(), root, other, &portgraph);
         // Update the optypes and metadata, copying them from the other graph.
         for (&node, &new_node) in node_map.iter() {
-            let nodetype = other.get_nodetype(node.into());
-            self.as_mut().op_types.set(new_node, nodetype.clone());
+            let optype = other.get_optype(node.into());
+            self.as_mut().op_types.set(new_node, optype.clone());
             let meta = other.base_hugr().metadata.get(node);
             self.as_mut().metadata.set(new_node, meta.clone());
         }

hugr-core/src/hugr/serialize.rs

@@ -48,7 +48,6 @@ impl<T> Versioned<T> {
 #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
 struct NodeSer {
     parent: Node,
-    input_extensions: Option<ExtensionSet>,
     #[serde(flatten)]
     op: OpType,
 }
@@ -143,12 +142,11 @@ impl TryFrom<&Hugr> for SerHugrV1 {
         let mut metadata = vec![None; hugr.node_count()];
         for n in hugr.nodes() {
             let parent = node_rekey[&hugr.get_parent(n).unwrap_or(n)];
-            let opt = hugr.get_nodetype(n);
+            let opt = hugr.get_optype(n);
             let new_node = node_rekey[&n].index();
             nodes[new_node] = Some(NodeSer {
                 parent,
-                input_extensions: opt.input_extensions.clone(),
-                op: opt.op.clone(),
+                op: opt.clone(),
             });
             metadata[new_node].clone_from(hugr.metadata.get(n.pg_index()));
         }

hugr-core/src/hugr/views.rs

@@ -79,8 +79,8 @@ pub trait HugrView: HugrInternals {
 
     /// Return the type of the HUGR root node.
     #[inline]
-    fn root_type(&self) -> &NodeType {
-        let node_type = self.get_nodetype(self.root());
+    fn root_type(&self) -> &OpType {
+        let op_type = self.get_optype(self.root());
         // Sadly no way to do this at present
         // debug_assert!(Self::RootHandle::can_hold(node_type.tag()));
         node_type