Merge branch 'release-rs-v0.16.0' into feat/persistenthugr

Author: lmondada

Cargo.lock

@@ -23,7 +23,7 @@ pub enum BoundaryPort<HostNode, P> {
 pub struct HostPort<N, P>(pub N, pub P);
 
 /// A port in the replacement graph.
-#[derive(Debug, Clone, Copy, From)]
+#[derive(Debug, Clone, Copy, From, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ReplacementPort<P>(pub Node, pub P);
 
 impl<HostNode: Copy, P> BoundaryPort<HostNode, P> {

hugr-core/src/hugr/patch/port_types.rs

@@ -573,7 +573,8 @@ pub(in crate::hugr::patch) mod test {
         DataflowSubContainer, HugrBuilder, ModuleBuilder,
     };
     use crate::extension::prelude::{bool_t, qb_t};
-    use crate::hugr::patch::PatchVerification;
+    use crate::hugr::patch::simple_replace::OutputBoundaryMap;
+    use crate::hugr::patch::{PatchVerification, ReplacementPort};
     use crate::hugr::views::{HugrView, SiblingSubgraph};
     use crate::hugr::{Hugr, HugrMut, Patch};
     use crate::ops::dataflow::DataflowOpTrait;
@@ -584,7 +585,7 @@ pub(in crate::hugr::patch) mod test {
     use crate::std_extensions::logic::LogicOp;
     use crate::types::{Signature, Type};
     use crate::utils::test_quantum_extension::{cx_gate, h_gate};
-    use crate::{IncomingPort, Node, OutgoingPort};
+    use crate::{Direction, IncomingPort, Node, OutgoingPort, Port};
 
     use super::SimpleReplacement;
 
@@ -801,6 +802,17 @@ pub(in crate::hugr::patch) mod test {
             nu_inp,
             nu_out: nu_out.into(),
         };
+
+        // Check output boundary
+        assert_eq!(
+            r.map_host_output((h_outp_node, h_port_2)).unwrap(),
+            ReplacementPort::from((r.get_replacement_io().unwrap()[1], n_port_2))
+        );
+        assert!(r
+            .map_host_output((h_outp_node, OutgoingPort::from(0)))
+            .is_none());
+
+        // Check invalidation set
         assert_eq!(
             HashSet::<_>::from_iter(r.invalidation_set()),
             HashSet::<_>::from_iter([h_node_cx, h_node_h0, h_node_h1, h_outp_node]),
@@ -1169,7 +1181,7 @@ pub(in crate::hugr::patch) mod test {
             .nodes()
             .find(|node: &Node| *h.get_optype(*node) == cx_gate().into())
             .unwrap();
-        let s: Vec<Node> = vec![h_node_cx].into_iter().collect();
+        let s = vec![h_node_cx];
         // 2. Construct a new DFG-rooted hugr for the replacement
         let n: Hugr = dfg_hugr2;
         // 3. Construct the input and output matchings
@@ -1209,6 +1221,58 @@ pub(in crate::hugr::patch) mod test {
         assert_eq!(h.validate(), Ok(()));
     }
 
+    #[rstest]
+    fn test_output_boundary_map(dfg_hugr2: Hugr) {
+        let [inp, out] = dfg_hugr2.get_io(dfg_hugr2.root()).unwrap();
+        let map = [
+            ((inp, OutgoingPort::from(0)), IncomingPort::from(0)),
+            ((inp, OutgoingPort::from(1)), IncomingPort::from(1)),
+        ]
+        .into_iter()
+        .collect();
+        let map = OutputBoundaryMap::ByOutgoing(map);
+
+        // Basic check: map as just defined
+        assert_eq!(
+            map.get(inp, OutgoingPort::from(0)),
+            Some(IncomingPort::from(0))
+        );
+        assert_eq!(
+            map.get(inp, OutgoingPort::from(1)),
+            Some(IncomingPort::from(1))
+        );
+
+        // Now check the map in terms of incoming ports
+        assert!(map.get(out, IncomingPort::from(0)).is_none());
+        assert_eq!(
+            map.get_as_incoming(out, IncomingPort::from(0), &dfg_hugr2),
+            Some(IncomingPort::from(0))
+        );
+
+        // Finally, check iterators
+        assert_eq!(
+            map.iter().collect::<HashSet<_>>(),
+            HashSet::from_iter([
+                (
+                    (inp, Port::new(Direction::Outgoing, 0)),
+                    IncomingPort::from(0)
+                ),
+                (
+                    (inp, Port::new(Direction::Outgoing, 1)),
+                    IncomingPort::from(1)
+                ),
+            ])
+        );
+        let h_gate = dfg_hugr2.output_neighbours(inp).nth(1).unwrap();
+        assert_eq!(
+            map.iter_as_incoming(&dfg_hugr2).collect::<HashSet<_>>(),
+            HashSet::from_iter([
+                ((out, IncomingPort::from(0)), IncomingPort::from(0)),
+                ((h_gate, IncomingPort::from(0)), IncomingPort::from(1)),
+            ])
+        );
+    }
+
     use crate::hugr::patch::replace::Replacement;
     fn to_replace(h: &impl HugrView<Node = Node>, s: SimpleReplacement) -> Replacement {
         use crate::hugr::patch::replace::{NewEdgeKind, NewEdgeSpec};

hugr-core/src/hugr/patch/simple_replace.rs

@@ -585,6 +585,7 @@ pub(crate) mod test {
     use crate::extension::PRELUDE;
     use crate::std_extensions::arithmetic::int_types::ConstInt;
     use crate::std_extensions::collections::array::{array_type, ArrayValue};
+    use crate::std_extensions::collections::value_array::{value_array_type, VArrayValue};
     use crate::{
         builder::{BuildError, DFGBuilder, Dataflow, DataflowHugr},
         extension::{
@@ -754,6 +755,11 @@ pub(crate) mod test {
         ArrayValue::new(bool_t(), [Value::true_val(), Value::false_val()]).into()
     }
 
+    #[fixture]
+    fn const_value_array_bool() -> Value {
+        VArrayValue::new(bool_t(), [Value::true_val(), Value::false_val()]).into()
+    }
+
     #[fixture]
     fn const_array_options() -> Value {
         let some_true = Value::some([Value::true_val()]);
@@ -762,17 +768,35 @@ pub(crate) mod test {
         ArrayValue::new(elem_ty.into(), [some_true, none]).into()
     }
 
+    #[fixture]
+    fn const_value_array_options() -> Value {
+        let some_true = Value::some([Value::true_val()]);
+        let none = Value::none(vec![bool_t()]);
+        let elem_ty = SumType::new_option(vec![bool_t()]);
+        VArrayValue::new(elem_ty.into(), [some_true, none]).into()
+    }
+
     #[rstest]
     #[case(Value::unit(), Type::UNIT, "const:seq:{}")]
     #[case(const_usize(), usize_t(), "const:custom:ConstUsize(")]
     #[case(serialized_float(17.4), float64_type(), "const:custom:json:Object")]
     #[case(const_tuple(), Type::new_tuple(vec![usize_t(), bool_t()]), "const:seq:{")]
     #[case(const_array_bool(), array_type(2, bool_t()), "const:custom:array")]
+    #[case(
+        const_value_array_bool(),
+        value_array_type(2, bool_t()),
+        "const:custom:value_array"
+    )]
     #[case(
         const_array_options(),
         array_type(2, SumType::new_option(vec![bool_t()]).into()),
         "const:custom:array"
     )]
+    #[case(
+        const_value_array_options(),
+        value_array_type(2, SumType::new_option(vec![bool_t()]).into()),
+        "const:custom:value_array"
+    )]
     fn const_type(
         #[case] const_value: Value,
         #[case] expected_type: Type,
@@ -792,7 +816,9 @@ pub(crate) mod test {
     #[case(const_serialized_usize(), const_usize())]
     #[case(const_tuple_serialized(), const_tuple())]
     #[case(const_array_bool(), const_array_bool())]
+    #[case(const_value_array_bool(), const_value_array_bool())]
     #[case(const_array_options(), const_array_options())]
+    #[case(const_value_array_options(), const_value_array_options())]
     // Opaque constants don't get resolved into concrete types when running miri,
     // as the `typetag` machinery is not available.
     #[cfg_attr(miri, ignore)]

hugr-core/src/ops/constant.rs

@@ -21,6 +21,7 @@ pub fn std_reg() -> ExtensionRegistry {
         collections::array::EXTENSION.to_owned(),
         collections::list::EXTENSION.to_owned(),
         collections::static_array::EXTENSION.to_owned(),
+        collections::value_array::EXTENSION.to_owned(),
         logic::EXTENSION.to_owned(),
         ptr::EXTENSION.to_owned(),
     ]);

hugr-core/src/std_extensions.rs

@@ -3,3 +3,4 @@
 pub mod array;
 pub mod list;
 pub mod static_array;
+pub mod value_array;