Add public:bool to FuncDefn

Author: acl-cqc

hugr-core/src/builder.rs

@@ -281,8 +281,7 @@ pub(crate) mod test {
 
     #[fixture]
     pub(crate) fn simple_funcdef_hugr() -> Hugr {
-        let fn_builder =
-            FunctionBuilder::new("test", Signature::new(vec![bool_t()], vec![bool_t()])).unwrap();
+        let fn_builder = FunctionBuilder::new("test", Signature::new_endo(bool_t())).unwrap();
         let [i1] = fn_builder.input_wires_arr();
         fn_builder.finish_hugr_with_outputs([i1]).unwrap()
     }

hugr-core/src/builder/build_traits.rs

@@ -83,7 +83,8 @@ pub trait Container {
     }
 
     /// Add a [`ops::FuncDefn`] node and returns a builder to define the function
-    /// body graph.
+    /// body graph. The function has the default [ops::FuncDefn::public] for the parent
+    /// (`false` with the default impl.)
     ///
     /// # Errors
     ///
@@ -93,13 +94,26 @@ pub trait Container {
         &mut self,
         name: impl Into<String>,
         signature: impl Into<PolyFuncType>,
+    ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
+        self.define_function_vis(name, signature, false)
+    }
+
+    /// Add a [`ops::FuncDefn`] node with the specified [visibility](ops::FuncDefn::public)
+    /// and returns a builder to define the function body graph.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if there is an error in adding the
+    /// [`ops::FuncDefn`] node.
+    fn define_function_vis(
+        &mut self,
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+        public: bool,
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
         let signature = 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.into(), signature, public));
 
         // Add the extensions used by the function types.
         self.use_extensions(

hugr-core/src/builder/dataflow.rs

@@ -138,20 +138,32 @@ 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-rooted HUGR; the function will be public.
+    /// (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 = signature.into();
-        let body = signature.body().clone();
-        let op = ops::FuncDefn {
-            signature,
-            name: name.into(),
-        };
+        Self::new_vis(name, signature, true)
+    }
+
+    /// Initialize a builder for a FuncDefn-rooted HUGR, with the specified
+    /// [visibility](ops::FuncDefn::public).
+    ///
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
+    pub fn new_vis(
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+        public: bool,
+    ) -> Result<Self, BuildError> {
+        let op = ops::FuncDefn::new(name.into(), signature.into(), public);
+        let body = op.signature.body().clone();
 
         let base = Hugr::new(op);
         let root = base.root();
@@ -243,24 +255,13 @@ 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,
-                },
-            )
-            .expect("Could not replace FunctionBuilder operation");
+        let fn_optype = self.hugr_mut().optype_mut(parent);
 
-        self.hugr().get_optype(parent).as_func_defn().unwrap()
+        let ops::OpType::FuncDefn(fd) = fn_optype else {
+            panic!("FunctionBuilder node must be a FuncDefn")
+        };
+        fd.signature = f(fd.inner_signature().into_owned()).into();
+        fn_optype.as_func_defn().unwrap()
     }
 }
 
@@ -528,8 +529,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])?;

hugr-core/src/builder/module.rs

@@ -8,9 +8,8 @@ use crate::hugr::internal::HugrMutInternals;
 use crate::hugr::views::HugrView;
 use crate::hugr::ValidationError;
 use crate::ops;
-use crate::types::{PolyFuncType, Type, TypeBound};
-
 use crate::ops::handle::{AliasID, FuncID, NodeHandle};
+use crate::types::{PolyFuncType, Type, TypeBound};
 
 use crate::{Hugr, Node};
 use smol_str::SmolStr;
@@ -33,6 +32,14 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> Container for ModuleBuilder<T> {
     fn hugr(&self) -> &Hugr {
         self.0.as_ref()
     }
+
+    fn define_function(
+        &mut self,
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+    ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
+        self.define_function_vis(name, signature, true)
+    }
 }
 
 impl ModuleBuilder<Hugr> {
@@ -60,7 +67,7 @@ impl HugrBuilder for ModuleBuilder<Hugr> {
 }
 
 impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
-    /// Replace a [`ops::FuncDecl`] with [`ops::FuncDefn`] and return a builder for
+    /// Replace a [`ops::FuncDecl`] with public [`ops::FuncDefn`] and return a builder for
     /// the defining graph.
     ///
     /// # Errors
@@ -72,19 +79,16 @@ 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 {
+        let opty = self.hugr_mut().optype_mut(f_node);
+        let ops::OpType::FuncDecl(ops::FuncDecl { signature, name }) = opty else {
+            return Err(BuildError::UnexpectedType {
                 node: f_node,
                 op_desc: "crate::ops::OpType::FuncDecl",
-            })?
-            .clone();
+            });
+        };
+
         let body = signature.body().clone();
-        self.hugr_mut()
-            .replace_op(f_node, ops::FuncDefn { name, signature })
-            .expect("Replacing a FuncDecl node with a FuncDefn should always be valid");
+        *opty = ops::FuncDefn::new_public(name, signature.clone()).into();
 
         let db = DFGBuilder::create_with_io(self.hugr_mut(), f_node, body)?;
         Ok(FunctionBuilder::from_dfg_builder(db))
@@ -203,10 +207,7 @@ mod test {
 
             let f_build = module_builder.define_function(
                 "main",
-                Signature::new(
-                    vec![qubit_state_type.get_alias_type()],
-                    vec![qubit_state_type.get_alias_type()],
-                ),
+                Signature::new_endo(qubit_state_type.get_alias_type()),
             )?;
             n_identity(f_build)?;
             module_builder.finish_hugr()

hugr-core/src/hugr/hugrmut.rs

@@ -653,12 +653,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()])
-                    .with_prelude()
-                    .into(),
-            },
+            ops::FuncDefn::new_public(
+                "main",
+                Signature::new(vec![usize_t()], vec![usize_t(), usize_t()]).with_prelude(),
+            ),
         );
 
         {
@@ -703,10 +701,7 @@ mod test {
         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(),
-                },
+                FuncDefn::new_private(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-core/src/hugr/serialize/test.rs

@@ -533,7 +533,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::FuncDefn { name: "polyfunc1".into(), signature: polyfunctype1(), public: true})]
+#[case(ops::FuncDefn { name: "polyfunc1".into(), signature: polyfunctype1(), public: false})]
 #[case(ops::FuncDecl { name: "polyfunc2".into(), signature: polyfunctype1()})]
 #[case(ops::AliasDefn { name: "aliasdefn".into(), definition: Type::new_unit_sum(4)})]
 #[case(ops::AliasDecl { name: "aliasdecl".into(), bound: TypeBound::Any})]

hugr-core/src/hugr/validate/test.rs

@@ -34,12 +34,10 @@ use crate::{
 ///
 /// 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])
-            .with_prelude()
-            .into(),
-    }
+    let def_op: OpType = ops::FuncDefn::new_public(
+        "main",
+        Signature::new(bool_t(), vec![bool_t(); copies]).with_prelude(),
+    )
     .into();
 
     let mut b = Hugr::default();
@@ -150,13 +148,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_private("main", def_sig));
     assert_matches!(
         b.validate(),
         Err(ValidationError::ContainerWithoutChildren { node, .. }) => assert_eq!(node, new_def)
@@ -349,10 +341,7 @@ fn identity_hugr_with_type(t: Type) -> (Hugr, Node) {
 
     let def = b.add_node_with_parent(
         b.root(),
-        ops::FuncDefn {
-            name: "main".into(),
-            signature: Signature::new(row.clone(), row.clone()).into(),
-        },
+        ops::FuncDefn::new_public("main", Signature::new_endo(row.clone())),
     );
 
     let input = b.add_node_with_parent(def, ops::Input::new(row.clone()));

hugr-core/src/hugr/views/sibling_subgraph.rs

@@ -457,8 +457,9 @@ impl SiblingSubgraph {
         &self,
         hugr: &impl HugrView<Node = Node>,
         name: impl Into<String>,
+        public: bool,
     ) -> Hugr {
-        let mut builder = FunctionBuilder::new(name, self.signature(hugr)).unwrap();
+        let mut builder = FunctionBuilder::new_vis(name, self.signature(hugr), public).unwrap();
         // Take the unfinished Hugr from the builder, to avoid unnecessary
         // validation checks that require connecting the inputs and outputs.
         let mut extracted = mem::take(builder.hugr_mut());
@@ -1175,7 +1176,7 @@ mod tests {
         let func_graph: SiblingGraph<'_, FuncID<true>> =
             SiblingGraph::try_new(&hugr, func_root).unwrap();
         let subgraph = SiblingSubgraph::try_new_dataflow_subgraph(&func_graph).unwrap();
-        let extracted = subgraph.extract_subgraph(&hugr, "region");
+        let extracted = subgraph.extract_subgraph(&hugr, "region", true);
 
         extracted.validate().unwrap();
     }

hugr-core/src/ops/module.rs

@@ -58,6 +58,29 @@ pub struct FuncDefn {
     pub name: String,
     /// Signature of the function
     pub signature: PolyFuncType,
+    /// Is the function public? (Can it be linked against and called externally?)
+    pub public: bool,
+}
+
+impl FuncDefn {
+    /// Create a new instance with the specified visibility
+    pub fn new(name: impl ToString, signature: impl Into<PolyFuncType>, public: bool) -> Self {
+        Self {
+            name: name.to_string(),
+            signature: signature.into(),
+            public,
+        }
+    }
+
+    /// Create a new instance with [Self::public] set
+    pub fn new_public(name: impl ToString, signature: impl Into<PolyFuncType>) -> Self {
+        Self::new(name, signature, true)
+    }
+
+    /// Create a new function that is not for external calls or linkage
+    pub fn new_private(name: impl ToString, signature: impl Into<PolyFuncType>) -> Self {
+        Self::new(name, signature, false)
+    }
 }
 
 impl_op_name!(FuncDefn);

hugr-core/src/package.rs

@@ -347,14 +347,8 @@ fn to_module_hugr(mut hugr: Hugr) -> Result<Hugr, PackageError> {
 
         // Convert the DFG into a `FuncDefn`
         hugr.set_num_ports(root, 0, 1);
-        hugr.replace_op(
-            root,
-            FuncDefn {
-                name: "main".to_string(),
-                signature: signature.into_owned().into(),
-            },
-        )
-        .expect("Hugr accepts any root node");
+        hugr.replace_op(root, FuncDefn::new_public("main", signature.into_owned()))
+            .expect("Hugr accepts any root node");
 
         // Wrap it in a module.
         let new_root = hugr.add_node(Module::new().into());