feat!: Improved array lowering (#2109)

Feature branch for improved array lowering.

* The old `array` type is now called `value_array` and lives in a
separate extension
* The default `array` is now a linear type with additional `clone` and
`discard` operations
* To avoid code duplication, array operations and values are now defined
generically over a new `ArrayKind` trait that is instantiated with
`Array` (the linear one) and `VArray` (the copyable one) to generate the
`array` and `value_array` extensions
* An `array<n, T>` is now lowered to a fat pointer `{ptr, usize}` where
`ptr` is a heap allocated pointer of size at least `n * sizeof(T)` and
the `usize` is an offset pointing to the first element (i.e. the first
element is at `ptr + offset * sizeof(T)`). The rational behind the
additional offset is the `pop_left` operation which bumps the offset
instead of mutating the pointer. This way, we can still free the
original pointer when the array is discarded after a pop.

Tracked PRs:
* #2097 (closes #2066)
* #2100
* #2101
* #2110
* #2112 (closes #2067)
* #2119
* #2125 (closes #2124)

BREAKING CHANGE: `std.collections.array` is now a linear type, even if
the contained elements are copyable. Use the new
`std.collections.value_array` for an array with the previous copyable
semantics.

BREAKING CHANGE: `std.collections.array.get` now also returns the passed
array as an extra output

BREAKING CHANGE: `ArrayOpBuilder` was moved from
`hugr_core::std_extensions::collections::array::op_builder` to
`hugr_core::std_extensions::collections::array`.

Author: mark-koch

Cargo.lock

@@ -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;