fix: Inline constant functions in QSystemPass (#961)

Fixes #958

The `inline_constant_functions` pass is defined in hugr-llvm so we need
to gate on the llvm feature :/

Author: mark-koch

tket2-hseries/src/lib.rs

@@ -21,6 +21,9 @@ use extension::{
     qsystem::{LowerTk2Error, LowerTket2ToQSystemPass, QSystemOp},
 };
 
+#[cfg(feature = "llvm")]
+use hugr::llvm::utils::inline_constant_functions;
+
 #[cfg(feature = "cli")]
 pub mod cli;
 pub mod extension;
@@ -66,6 +69,9 @@ pub enum QSystemPassError<N = Node> {
     ConstantFoldError(ConstFoldError),
     /// An error from the component [LinearizeArrayPass] pass.
     LinearizeArrayError(ReplaceTypesError),
+    #[cfg(feature = "llvm")]
+    /// An error from the component [inline_constant_functions()] pass.
+    InlineConstantFunctionsError(anyhow::Error),
     /// An error when running [RemoveDeadFuncsPass] after the monomorphisation
     /// pass.
     ///
@@ -112,6 +118,12 @@ impl QSystemPass {
             self.replace_bools().run(hugr)?;
         }
         self.linearize_arrays().run(hugr)?;
+        #[cfg(feature = "llvm")]
+        {
+            // TODO: Remove "llvm" feature gate once `inline_constant_functions` is moved to
+            //  `hugr-passes`. See https://github.com/CQCL/hugr/issues/2419
+            inline_constant_functions(hugr)?;
+        }
         if self.constant_fold {
             self.constant_fold().run(hugr)?;
         }
@@ -326,4 +338,49 @@ mod test {
             assert!(get_pos(call_node) < get_pos(n));
         }
     }
+
+    #[cfg(feature = "llvm")]
+    #[test]
+    fn const_function() {
+        use hugr::builder::DataflowHugr;
+        use hugr::builder::{DFGBuilder, ModuleBuilder};
+        use hugr::ops::{CallIndirect, Value};
+
+        let qb_sig: Signature = Signature::new_endo(qb_t());
+        let mut hugr = {
+            let mut builder = ModuleBuilder::new();
+            let val = Value::function({
+                let builder = DFGBuilder::new(Signature::new_endo(qb_t())).unwrap();
+                let [r] = builder.input_wires_arr();
+                builder.finish_hugr_with_outputs([r]).unwrap()
+            })
+            .unwrap();
+            let const_node = builder.add_constant(val);
+            {
+                let mut builder = builder.define_function("main", qb_sig.clone()).unwrap();
+                let [i] = builder.input_wires_arr();
+                let fun = builder.load_const(&const_node);
+                let [r] = builder
+                    .add_dataflow_op(
+                        CallIndirect {
+                            signature: qb_sig.clone(),
+                        },
+                        [fun, i],
+                    )
+                    .unwrap()
+                    .outputs_arr();
+                builder.finish_with_outputs([r]).unwrap();
+            };
+            builder.finish_hugr().unwrap()
+        };
+
+        QSystemPass::default().run(&mut hugr).unwrap();
+
+        // QSystemPass should have removed the const function
+        for n in hugr.descendants(hugr.module_root()) {
+            if hugr.get_optype(n).as_const().is_some() {
+                panic!("Const function is still there!");
+            }
+        }
+    }
 }