WIP Add link_name, builder methods, update some passes

dead_funcs.rs: add enum IncludeExports
monomorphize.rs: bodge TODO

Author: acl-cqc

hugr-core/src/builder.rs

@@ -295,8 +295,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

@@ -127,6 +127,26 @@ pub trait Container {
     }
 }
 
+/*pub(super) fn define_function_link_name<C: Container + ?Sized>(
+    ctr: &mut C,
+    name: impl Into<String>,
+    signature: impl Into<PolyFuncType>,
+    link_name: impl Into<Option<String>>,
+) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
+    let signature = signature.into();
+    let body = signature.body().clone();
+    let f_node = ctr.add_child_node(ops::FuncDefn::new(name.into(), signature, link_name));
+
+    // Add the extensions used by the function types.
+    ctr.use_extensions(
+        body.used_extensions()
+            .unwrap_or_else(|e| panic!("Build-time signatures should have valid extensions. {e}")),
+    );
+
+    let db = DFGBuilder::create_with_io(ctr.hugr_mut(), f_node, body)?;
+    Ok(FunctionBuilder::from_dfg_builder(db))
+}*/
+
 /// Types implementing this trait can be used to build complete HUGRs
 /// (with varying entrypoint node types)
 pub trait HugrBuilder: Container {

hugr-core/src/builder/dataflow.rs

@@ -152,17 +152,46 @@ 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`](ops::FuncDefn)-rooted HUGR; the function will be private.
+    /// (See also [Self::new_pub], [Self::new_link_name].)
+    ///
     /// # Errors
     ///
     /// Error in adding DFG child nodes.
     pub fn new(
         name: impl Into<String>,
         signature: impl Into<PolyFuncType>,
     ) -> Result<Self, BuildError> {
-        let signature: PolyFuncType = signature.into();
-        let body = signature.body().clone();
-        let op = ops::FuncDefn::new(name, signature);
+        Self::new_link_name(name, signature, None)
+    }
+
+    /// Initialize a builder for a FuncDefn-rooted HUGR; the function will be public
+    /// with the same name (see also [Self::new_link_name]).
+    ///
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
+    pub fn new_pub(
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+    ) -> Result<Self, BuildError> {
+        let name = name.into();
+        Self::new_link_name(name.clone(), signature, Some(name))
+    }
+
+    /// Initialize a builder for a FuncDefn-rooted HUGR, with the specified
+    /// [link_name](ops::FuncDefn::link_name).
+    ///
+    /// # Errors
+    ///
+    /// Error in adding DFG child nodes.
+    pub fn new_link_name(
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+        link_name: impl Into<Option<String>>,
+    ) -> Result<Self, BuildError> {
+        let op = ops::FuncDefn::new_link_name(name.into(), signature.into(), link_name);
+        let body = op.signature().body().clone();
 
         let base = Hugr::new_with_entrypoint(op).expect("FuncDefn entrypoint should be valid");
         let root = base.entrypoint();

hugr-core/src/builder/module.rs

@@ -8,11 +8,10 @@ use crate::hugr::ValidationError;
 use crate::hugr::internal::HugrMutInternals;
 use crate::hugr::views::HugrView;
 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;
 
 /// Builder for a HUGR module.
@@ -51,7 +50,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
@@ -63,19 +62,50 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
         f_id: &FuncID<false>,
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
         let f_node = f_id.node();
-        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::new(name, sig));
+        let opty = self.hugr_mut().optype_mut(f_node);
+        let ops::OpType::FuncDecl(decl) = opty else {
+            return Err(BuildError::UnexpectedType {
+                node: f_node,
+                op_desc: "crate::ops::OpType::FuncDecl",
+            });
+        };
+
+        let body = decl.signature().body().clone();
+        // TODO look for `name_hint` metadata on the FuncDecl and copy to FuncDefn
+        *opty = ops::FuncDefn::new_link_name(
+            format!("From Decl {}", decl.link_name()),
+            decl.signature().clone(),
+            decl.link_name().clone(),
+        )
+        .into();
+
+        let db = DFGBuilder::create_with_io(self.hugr_mut(), f_node, body)?;
+        Ok(FunctionBuilder::from_dfg_builder(db))
+    }
+
+    /// Add a [`ops::FuncDefn`] node, with both `name` and `link_name` explicitly specified.
+    /// 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.
+    pub fn define_function_link_name(
+        &mut self,
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+        link_name: impl Into<Option<String>>,
+    ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
+        let signature: PolyFuncType = signature.into();
+        let body = signature.body().clone();
+        let f_node = self.add_child_node(ops::FuncDefn::new_link_name(name, signature, link_name));
+
+        // Add the extensions used by the function types.
+        self.use_extensions(
+            body.used_extensions().unwrap_or_else(|e| {
+                panic!("Build-time signatures should have valid extensions. {e}")
+            }),
+        );
 
         let db = DFGBuilder::create_with_io(self.hugr_mut(), f_node, body)?;
         Ok(FunctionBuilder::from_dfg_builder(db))
@@ -106,31 +136,36 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
         Ok(declare_n.into())
     }
 
-    /// Add a [`ops::FuncDefn`] node and returns a builder to define the function
+    /// Adds a private [`ops::FuncDefn`] node 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.
+    // ALAN TODO? deprecate and rename to define_private_func(tion)? (Rather long...)
     pub fn define_function(
         &mut self,
         name: impl Into<String>,
         signature: impl Into<PolyFuncType>,
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
-        let signature: PolyFuncType = signature.into();
-        let body = signature.body().clone();
-        let f_node = self.add_child_node(ops::FuncDefn::new(name, signature));
-
-        // Add the extensions used by the function types.
-        self.use_extensions(
-            body.used_extensions().unwrap_or_else(|e| {
-                panic!("Build-time signatures should have valid extensions. {e}")
-            }),
-        );
+        self.define_function_link_name(name, signature, None)
+    }
 
-        let db = DFGBuilder::create_with_io(self.hugr_mut(), f_node, body)?;
-        Ok(FunctionBuilder::from_dfg_builder(db))
+    /// Adds a public [`ops::FuncDefn`] node, with `link_name` the same as `name`,
+    /// 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.
+    pub fn define_function_pub(
+        &mut self,
+        name: impl Into<String>,
+        signature: impl Into<PolyFuncType>,
+    ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
+        let name = name.into();
+        self.define_function_link_name(name.clone(), signature, name)
     }
 
     /// Add a [`crate::ops::OpType::AliasDefn`] node and return a handle to the Alias.
@@ -218,10 +253,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.rs

@@ -500,7 +500,8 @@ 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::new("main", signature.clone()));
+        let func =
+            hugr.add_node_with_parent(module, ops::FuncDefn::new_public("main", signature.clone()));
         let inp = hugr.add_node_with_parent(
             func,
             ops::Input {

hugr-core/src/hugr/hugrmut.rs

@@ -630,7 +630,7 @@ mod test {
         // Start a main function with two nat inputs.
         let f: Node = hugr.add_node_with_parent(
             module,
-            ops::FuncDefn::new(
+            ops::FuncDefn::new_public(
                 "main",
                 Signature::new(usize_t(), vec![usize_t(), usize_t()]),
             ),

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

@@ -506,7 +506,8 @@ fn roundtrip_polyfunctype_varlen(#[case] poly_func_type: PolyFuncTypeRV) {
 
 #[rstest]
 #[case(ops::Module::new())]
-#[case(ops::FuncDefn::new("polyfunc1", polyfunctype1()))]
+#[case(ops::FuncDefn::new_private("polyfunc1", polyfunctype1()))]
+#[case(ops::FuncDefn::new_link_name("pubfunc1", polyfunctype1(), "func1linkname".to_string()))]
 #[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})]