feat!: Hide FuncDefn/cl fields, add accessors and ::new(...) (#2213)

acl-cqc · web-flow · commit 0280eb2c50ed · 2025-05-14T13:04:44.000Z
Accessors ::func_name, ::func_name_mut, ::signature, ::signature_mut.

Constructor ::new takes name + sig using `impl Into`.

BREAKING CHANGE: construction, destruction, and field access should use
new methods
diff --git a/hugr-core/src/builder/build_traits.rs b/hugr-core/src/builder/build_traits.rs
@@ -96,10 +96,7 @@ pub trait Container {
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
         let signature: PolyFuncType = signature.into();
         let body = signature.body().clone();
-        let f_node = self.add_child_node(ops::FuncDefn {
-            name: name.into(),
-            signature,
-        });
+        let f_node = self.add_child_node(ops::FuncDefn::new(name, signature));
 
         // Add the extensions used by the function types.
         self.use_extensions(
@@ -401,8 +398,8 @@ pub trait Dataflow: Container {
         let func_node = fid.node();
         let func_op = self.hugr().get_optype(func_node);
         let func_sig = match func_op {
-            OpType::FuncDefn(ops::FuncDefn { signature, .. })
-            | OpType::FuncDecl(ops::FuncDecl { signature, .. }) => signature.clone(),
+            OpType::FuncDefn(fd) => fd.signature().clone(),
+            OpType::FuncDecl(fd) => fd.signature().clone(),
             _ => {
                 return Err(BuildError::UnexpectedType {
                     node: func_node,
@@ -617,8 +614,8 @@ pub trait Dataflow: Container {
         let hugr = self.hugr();
         let def_op = hugr.get_optype(function.node());
         let type_scheme = match def_op {
-            OpType::FuncDefn(ops::FuncDefn { signature, .. })
-            | OpType::FuncDecl(ops::FuncDecl { signature, .. }) => signature.clone(),
+            OpType::FuncDefn(fd) => fd.signature().clone(),
+            OpType::FuncDecl(fd) => fd.signature().clone(),
             _ => {
                 return Err(BuildError::UnexpectedType {
                     node: function.node(),
diff --git a/hugr-core/src/builder/dataflow.rs b/hugr-core/src/builder/dataflow.rs
@@ -162,10 +162,7 @@ impl FunctionBuilder<Hugr> {
     ) -> Result<Self, BuildError> {
         let signature: PolyFuncType = signature.into();
         let body = signature.body().clone();
-        let op = ops::FuncDefn {
-            signature,
-            name: name.into(),
-        };
+        let op = ops::FuncDefn::new(name, signature);
 
         let base = Hugr::new_with_entrypoint(op).expect("FuncDefn entrypoint should be valid");
         let root = base.entrypoint();
@@ -187,7 +184,7 @@ impl FunctionBuilder<Hugr> {
         });
 
         // Update the inner input node
-        let types = new_optype.signature.body().input.clone();
+        let types = new_optype.signature().body().input.clone();
         self.hugr_mut().replace_op(inp_node, Input { types });
         let mut new_port = self.hugr_mut().add_ports(inp_node, Direction::Outgoing, 1);
         let new_port = new_port.next().unwrap();
@@ -222,7 +219,7 @@ impl FunctionBuilder<Hugr> {
         });
 
         // Update the inner input node
-        let types = new_optype.signature.body().output.clone();
+        let types = new_optype.signature().body().output.clone();
         self.hugr_mut().replace_op(out_node, Output { types });
         let mut new_port = self.hugr_mut().add_ports(out_node, Direction::Incoming, 1);
         let new_port = new_port.next().unwrap();
@@ -253,22 +250,12 @@ impl FunctionBuilder<Hugr> {
     /// Returns a reference to the new optype.
     fn update_fn_signature(&mut self, f: impl FnOnce(Signature) -> Signature) -> &ops::FuncDefn {
         let parent = self.container_node();
-        let old_optype = self
-            .hugr()
-            .get_optype(parent)
-            .as_func_defn()
-            .expect("FunctionBuilder node must be a FuncDefn");
-        let signature = old_optype.inner_signature().into_owned();
-        let name = old_optype.name.clone();
-        self.hugr_mut().replace_op(
-            parent,
-            ops::FuncDefn {
-                signature: f(signature).into(),
-                name,
-            },
-        );
 
-        self.hugr().get_optype(parent).as_func_defn().unwrap()
+        let ops::OpType::FuncDefn(fd) = self.hugr_mut().optype_mut(parent) else {
+            panic!("FunctionBuilder node must be a FuncDefn")
+        };
+        *fd.signature_mut() = f(fd.inner_signature().into_owned()).into();
+        &*fd
     }
 }
 
@@ -531,8 +518,8 @@ pub(crate) mod test {
         let mut module_builder = ModuleBuilder::new();
 
         let (dfg_node, f_node) = {
-            let mut f_build = module_builder
-                .define_function("main", Signature::new(vec![bool_t()], vec![bool_t()]))?;
+            let mut f_build =
+                module_builder.define_function("main", Signature::new_endo(bool_t()))?;
 
             let [i1] = f_build.input_wires_arr();
             let dfg = f_build.add_hugr_with_wires(dfg_hugr, [i1])?;
diff --git a/hugr-core/src/builder/module.rs b/hugr-core/src/builder/module.rs
@@ -69,18 +69,19 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
         f_id: &FuncID<false>,
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
         let f_node = f_id.node();
-        let ops::FuncDecl { signature, name } = self
-            .hugr()
-            .get_optype(f_node)
-            .as_func_decl()
-            .ok_or(BuildError::UnexpectedType {
-                node: f_node,
-                op_desc: "crate::ops::OpType::FuncDecl",
-            })?
-            .clone();
-        let body = signature.body().clone();
+        let decl =
+            self.hugr()
+                .get_optype(f_node)
+                .as_func_decl()
+                .ok_or(BuildError::UnexpectedType {
+                    node: f_node,
+                    op_desc: "crate::ops::OpType::FuncDecl",
+                })?;
+        let name = decl.func_name().clone();
+        let sig = decl.signature().clone();
+        let body = sig.body().clone();
         self.hugr_mut()
-            .replace_op(f_node, ops::FuncDefn { name, signature });
+            .replace_op(f_node, ops::FuncDefn::new(name, sig));
 
         let db = DFGBuilder::create_with_io(self.hugr_mut(), f_node, body)?;
         Ok(FunctionBuilder::from_dfg_builder(db))
@@ -99,10 +100,7 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
     ) -> Result<FuncID<false>, BuildError> {
         let body = signature.body().clone();
         // TODO add param names to metadata
-        let declare_n = self.add_child_node(ops::FuncDecl {
-            signature,
-            name: name.into(),
-        });
+        let declare_n = self.add_child_node(ops::FuncDecl::new(name, signature));
 
         // Add the extensions used by the function types.
         self.use_extensions(
diff --git a/hugr-core/src/export.rs b/hugr-core/src/export.rs
@@ -226,8 +226,8 @@ impl<'a> Context<'a> {
     /// one of those operations.
     fn get_func_name(&self, func_node: Node) -> Option<&'a str> {
         match self.hugr.get_optype(func_node) {
-            OpType::FuncDecl(func_decl) => Some(&func_decl.name),
-            OpType::FuncDefn(func_defn) => Some(&func_defn.name),
+            OpType::FuncDecl(func_decl) => Some(func_decl.func_name()),
+            OpType::FuncDefn(func_defn) => Some(func_defn.func_name()),
             _ => None,
         }
     }
@@ -260,8 +260,8 @@ impl<'a> Context<'a> {
 
         // We record the name of the symbol defined by the node, if any.
         let symbol = match optype {
-            OpType::FuncDefn(func_defn) => Some(func_defn.name.as_str()),
-            OpType::FuncDecl(func_decl) => Some(func_decl.name.as_str()),
+            OpType::FuncDefn(func_defn) => Some(func_defn.func_name().as_str()),
+            OpType::FuncDecl(func_decl) => Some(func_decl.func_name().as_str()),
             OpType::AliasDecl(alias_decl) => Some(alias_decl.name.as_str()),
             OpType::AliasDefn(alias_defn) => Some(alias_defn.name.as_str()),
             _ => None,
@@ -331,7 +331,7 @@ impl<'a> Context<'a> {
 
             OpType::FuncDefn(func) => self.with_local_scope(node_id, |this| {
                 let name = this.get_func_name(node).unwrap();
-                let symbol = this.export_poly_func_type(name, &func.signature);
+                let symbol = this.export_poly_func_type(name, func.signature());
                 regions = this.bump.alloc_slice_copy(&[this.export_dfg(
                     node,
                     model::ScopeClosure::Closed,
@@ -342,7 +342,7 @@ impl<'a> Context<'a> {
 
             OpType::FuncDecl(func) => self.with_local_scope(node_id, |this| {
                 let name = this.get_func_name(node).unwrap();
-                let symbol = this.export_poly_func_type(name, &func.signature);
+                let symbol = this.export_poly_func_type(name, func.signature());
                 table::Operation::DeclareFunc(symbol)
             }),
 
diff --git a/hugr-core/src/extension/resolution/types.rs b/hugr-core/src/extension/resolution/types.rs
@@ -42,8 +42,12 @@ pub(crate) fn collect_op_types_extensions(
             }
             collect_signature_exts(&ext.signature(), &mut used, &mut missing);
         }
-        OpType::FuncDefn(f) => collect_signature_exts(f.signature.body(), &mut used, &mut missing),
-        OpType::FuncDecl(f) => collect_signature_exts(f.signature.body(), &mut used, &mut missing),
+        OpType::FuncDefn(f) => {
+            collect_signature_exts(f.signature().body(), &mut used, &mut missing)
+        }
+        OpType::FuncDecl(f) => {
+            collect_signature_exts(f.signature().body(), &mut used, &mut missing)
+        }
         OpType::Const(c) => collect_value_exts(&c.value, &mut used, &mut missing),
         OpType::Input(inp) => collect_type_row_exts(&inp.types, &mut used, &mut missing),
         OpType::Output(out) => collect_type_row_exts(&out.types, &mut used, &mut missing),
diff --git a/hugr-core/src/extension/resolution/types_mut.rs b/hugr-core/src/extension/resolution/types_mut.rs
@@ -35,10 +35,20 @@ pub fn resolve_op_types_extensions(
             resolve_signature_exts(node, ext.signature_mut(), extensions, used_extensions)?;
         }
         OpType::FuncDefn(f) => {
-            resolve_signature_exts(node, f.signature.body_mut(), extensions, used_extensions)?;
+            resolve_signature_exts(
+                node,
+                f.signature_mut().body_mut(),
+                extensions,
+                used_extensions,
+            )?;
         }
         OpType::FuncDecl(f) => {
-            resolve_signature_exts(node, f.signature.body_mut(), extensions, used_extensions)?;
+            resolve_signature_exts(
+                node,
+                f.signature_mut().body_mut(),
+                extensions,
+                used_extensions,
+            )?;
         }
         OpType::Const(c) => resolve_value_exts(node, &mut c.value, extensions, used_extensions)?,
         OpType::Input(inp) => {
diff --git a/hugr-core/src/hugr.rs b/hugr-core/src/hugr.rs
@@ -443,13 +443,7 @@ fn make_module_hugr(root_op: OpType, nodes: usize, ports: usize) -> Option<Hugr>
         let dataflow_inputs = signature.input_count();
         let dataflow_outputs = signature.output_count();
 
-        let func = hugr.add_node_with_parent(
-            module,
-            ops::FuncDefn {
-                name: "main".into(),
-                signature: signature.clone().into(),
-            },
-        );
+        let func = hugr.add_node_with_parent(module, ops::FuncDefn::new("main", signature.clone()));
         let inp = hugr.add_node_with_parent(
             func,
             ops::Input {
diff --git a/hugr-core/src/hugr/hugrmut.rs b/hugr-core/src/hugr/hugrmut.rs
@@ -630,10 +630,10 @@ mod test {
         // Start a main function with two nat inputs.
         let f: Node = hugr.add_node_with_parent(
             module,
-            ops::FuncDefn {
-                name: "main".into(),
-                signature: Signature::new(vec![usize_t()], vec![usize_t(), usize_t()]).into(),
-            },
+            ops::FuncDefn::new(
+                "main",
+                Signature::new(usize_t(), vec![usize_t(), usize_t()]),
+            ),
         );
 
         {
@@ -676,13 +676,8 @@ mod test {
         hugr.use_extension(PRELUDE.to_owned());
         let root = hugr.entrypoint();
         let [foo, bar] = ["foo", "bar"].map(|name| {
-            let fd = hugr.add_node_with_parent(
-                root,
-                FuncDefn {
-                    name: name.to_string(),
-                    signature: Signature::new_endo(usize_t()).into(),
-                },
-            );
+            let fd = hugr
+                .add_node_with_parent(root, FuncDefn::new(name, Signature::new_endo(usize_t())));
             let inp = hugr.add_node_with_parent(fd, Input::new(usize_t()));
             let out = hugr.add_node_with_parent(fd, Output::new(usize_t()));
             hugr.connect(inp, 0, out, 0);
diff --git a/hugr-core/src/hugr/serialize/test.rs b/hugr-core/src/hugr/serialize/test.rs
@@ -506,8 +506,8 @@ fn roundtrip_polyfunctype_varlen(#[case] poly_func_type: PolyFuncTypeRV) {
 
 #[rstest]
 #[case(ops::Module::new())]
-#[case(ops::FuncDefn { name: "polyfunc1".into(), signature: polyfunctype1()})]
-#[case(ops::FuncDecl { name: "polyfunc2".into(), signature: polyfunctype1()})]
+#[case(ops::FuncDefn::new("polyfunc1", polyfunctype1()))]
+#[case(ops::FuncDecl::new("polyfunc2", polyfunctype1()))]
 #[case(ops::AliasDefn { name: "aliasdefn".into(), definition: Type::new_unit_sum(4)})]
 #[case(ops::AliasDecl { name: "aliasdecl".into(), bound: TypeBound::Any})]
 #[case(ops::Const::new(Value::false_val()))]
diff --git a/hugr-core/src/hugr/validate.rs b/hugr-core/src/hugr/validate.rs
@@ -16,7 +16,7 @@ use crate::ops::custom::{ExtensionOp, OpaqueOpError};
 use crate::ops::validate::{
     ChildrenEdgeData, ChildrenValidationError, EdgeValidationError, OpValidityFlags,
 };
-use crate::ops::{FuncDefn, NamedOp, OpName, OpTag, OpTrait, OpType, ValidateOp};
+use crate::ops::{NamedOp, OpName, OpTag, OpTrait, OpType, ValidateOp};
 use crate::types::EdgeKind;
 use crate::types::type_param::TypeParam;
 use crate::{Direction, Port};
@@ -580,8 +580,8 @@ impl<'a, H: HugrView> ValidationContext<'a, H> {
 
         // For FuncDefn's, only the type variables declared by the FuncDefn can be referred to by nodes
         // inside the function. (The same would be true for FuncDecl's, but they have no child nodes.)
-        let var_decls = if let OpType::FuncDefn(FuncDefn { signature, .. }) = op_type {
-            signature.params()
+        let var_decls = if let OpType::FuncDefn(fd) = op_type {
+            fd.signature().params()
         } else {
             var_decls
         };
diff --git a/hugr-core/src/hugr/validate/test.rs b/hugr-core/src/hugr/validate/test.rs
@@ -31,11 +31,8 @@ use crate::{Direction, Hugr, IncomingPort, Node, const_extension_ids, test_file,
 ///
 /// Returns the hugr and the node index of the definition.
 fn make_simple_hugr(copies: usize) -> (Hugr, Node) {
-    let def_op: OpType = ops::FuncDefn {
-        name: "main".into(),
-        signature: Signature::new(vec![bool_t()], vec![bool_t(); copies]).into(),
-    }
-    .into();
+    let def_op: OpType =
+        ops::FuncDefn::new("main", Signature::new(bool_t(), vec![bool_t(); copies])).into();
 
     let mut b = Hugr::default();
     let root = b.entrypoint();
@@ -129,13 +126,7 @@ fn children_restrictions() {
 
     // Add a definition without children
     let def_sig = Signature::new(vec![bool_t()], vec![bool_t(), bool_t()]);
-    let new_def = b.add_node_with_parent(
-        root,
-        ops::FuncDefn {
-            signature: def_sig.into(),
-            name: "main".into(),
-        },
-    );
+    let new_def = b.add_node_with_parent(root, ops::FuncDefn::new("main", def_sig));
     assert_matches!(
         b.validate(),
         Err(ValidationError::ContainerWithoutChildren { node, .. }) => assert_eq!(node, new_def)
@@ -314,10 +305,7 @@ fn identity_hugr_with_type(t: Type) -> (Hugr, Node) {
 
     let def = b.add_node_with_parent(
         b.entrypoint(),
-        ops::FuncDefn {
-            name: "main".into(),
-            signature: Signature::new(row.clone(), row.clone()).into(),
-        },
+        ops::FuncDefn::new("main", Signature::new_endo(row.clone())),
     );
 
     let input = b.add_node_with_parent(def, ops::Input::new(row.clone()));
diff --git a/hugr-core/src/hugr/views.rs b/hugr-core/src/hugr/views.rs
@@ -363,8 +363,8 @@ pub trait HugrView: HugrInternals {
     /// a [`FuncDecl`][crate::ops::FuncDecl] or [`FuncDefn`][crate::ops::FuncDefn].
     fn poly_func_type(&self) -> Option<PolyFuncType> {
         match self.entrypoint_optype() {
-            OpType::FuncDecl(decl) => Some(decl.signature.clone()),
-            OpType::FuncDefn(defn) => Some(defn.signature.clone()),
+            OpType::FuncDecl(decl) => Some(decl.signature().clone()),
+            OpType::FuncDefn(defn) => Some(defn.signature().clone()),
             _ => None,
         }
     }
diff --git a/hugr-core/src/hugr/views/render.rs b/hugr-core/src/hugr/views/render.rs
@@ -40,8 +40,8 @@ pub(super) fn node_style(
 ) -> Box<dyn FnMut(NodeIndex) -> NodeStyle + '_> {
     fn node_name(h: &Hugr, n: NodeIndex) -> String {
         match h.get_optype(n.into()) {
-            OpType::FuncDecl(f) => format!("FuncDecl: \"{}\"", f.name),
-            OpType::FuncDefn(f) => format!("FuncDefn: \"{}\"", f.name),
+            OpType::FuncDecl(f) => format!("FuncDecl: \"{}\"", f.func_name()),
+            OpType::FuncDefn(f) => format!("FuncDefn: \"{}\"", f.func_name()),
             op => op.name().to_string(),
         }
     }
diff --git a/hugr-core/src/hugr/views/sibling_subgraph.rs b/hugr-core/src/hugr/views/sibling_subgraph.rs
@@ -1190,7 +1190,7 @@ mod tests {
         let func =
             SiblingSubgraph::try_new_dataflow_subgraph::<_, FuncID<true>>(&func_graph).unwrap();
         let func_defn = hugr.get_optype(func_root).as_func_defn().unwrap();
-        assert_eq!(func_defn.signature, func.signature(&func_graph).into());
+        assert_eq!(func_defn.signature(), &func.signature(&func_graph).into());
     }
 
     #[test]
diff --git a/hugr-core/src/import.rs b/hugr-core/src/import.rs
@@ -412,10 +412,7 @@ impl<'a> Context<'a> {
 
             table::Operation::DefineFunc(symbol) => {
                 self.import_poly_func_type(node_id, *symbol, |ctx, signature| {
-                    let optype = OpType::FuncDefn(FuncDefn {
-                        name: symbol.name.to_string(),
-                        signature,
-                    });
+                    let optype = OpType::FuncDefn(FuncDefn::new(symbol.name, signature));
 
                     let node = ctx.make_node(node_id, optype, parent)?;
 
@@ -431,10 +428,7 @@ impl<'a> Context<'a> {
 
             table::Operation::DeclareFunc(symbol) => {
                 self.import_poly_func_type(node_id, *symbol, |ctx, signature| {
-                    let optype = OpType::FuncDecl(FuncDecl {
-                        name: symbol.name.to_string(),
-                        signature,
-                    });
+                    let optype = OpType::FuncDecl(FuncDecl::new(symbol.name, signature));
 
                     let node = ctx.make_node(node_id, optype, parent)?;
 
diff --git a/hugr-core/src/ops/module.rs b/hugr-core/src/ops/module.rs
diff --git a/hugr-llvm/src/emit.rs b/hugr-llvm/src/emit.rs
diff --git a/hugr-llvm/src/utils/inline_constant_functions.rs b/hugr-llvm/src/utils/inline_constant_functions.rs
diff --git a/hugr-passes/src/dead_funcs.rs b/hugr-passes/src/dead_funcs.rs
diff --git a/hugr-passes/src/monomorphize.rs b/hugr-passes/src/monomorphize.rs
diff --git a/hugr-passes/src/replace_types.rs b/hugr-passes/src/replace_types.rs
