Merge branch 'main' into ab/sibling-subgraph-from-node

Author: aborgna-q

.gitignore

@@ -12,6 +12,9 @@ target/
 # Failing proptest artifacts
 proptest-regressions/
 
+# snaphsot test failures
+*.snap.new
+
 # Devenv
 .devenv*
 devenv.local.nix

hugr-core/src/std_extensions/collections/static_array.rs

@@ -14,23 +14,27 @@
 //!  * `get<T: Copyable>: [static_array<T>, prelude.usize] -> [[] + [T]]`
 //!  * `len<T: Copyable>: [static_array<T>] -> [prelude.usize]`
 use std::{
-    hash, iter,
+    hash::{self, Hash as _},
+    iter,
     sync::{self, Arc},
 };
 
 use crate::{
     builder::{BuildError, Dataflow},
     extension::{
         prelude::{option_type, usize_t},
-        resolution::{ExtensionResolutionError, WeakExtensionRegistry},
+        resolution::{
+            resolve_type_extensions, resolve_value_extensions, ExtensionResolutionError,
+            WeakExtensionRegistry,
+        },
         simple_op::{
             try_from_name, HasConcrete, HasDef, MakeExtensionOp, MakeOpDef, MakeRegisteredOp,
             OpLoadError,
         },
         ExtensionId, ExtensionSet, OpDef, SignatureError, SignatureFunc, TypeDef,
     },
     ops::{
-        constant::{CustomConst, TryHash, ValueName},
+        constant::{maybe_hash_values, CustomConst, TryHash, ValueName},
         ExtensionOp, NamedOp, OpName, Value,
     },
     types::{
@@ -41,9 +45,6 @@ use crate::{
     Extension, Wire,
 };
 
-use super::array::ArrayValue;
-
-use delegate::delegate;
 use lazy_static::lazy_static;
 
 /// Reported unique name of the extension
@@ -53,22 +54,25 @@ pub const STATIC_ARRAY_TYPENAME: TypeName = TypeName::new_inline("static_array")
 /// Extension version.
 pub const VERSION: semver::Version = semver::Version::new(0, 1, 0);
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, derive_more::From)]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, derive_more::From)]
 /// Statically sized array of values, all of the same [TypeBound::Copyable]
 /// type.
 pub struct StaticArrayValue {
-    /// The contents of the `StaticArrayValue`.
-    pub value: ArrayValue,
+    values: Vec<Value>,
+    typ: Type,
     /// The name of the `StaticArrayValue`.
     pub name: String,
 }
 
 impl StaticArrayValue {
-    delegate! {
-        to self.value {
-            /// Returns the type of values inside the `[StaticArrayValue]`.
-            pub fn get_element_type(&self) -> &Type;
-        }
+    /// Returns the type of values inside the `[StaticArrayValue]`.
+    pub fn get_element_type(&self) -> &Type {
+        &self.typ
+    }
+
+    /// Returns the values contained inside the `[StaticArrayValue]`.
+    pub fn get_contents(&self) -> &[Value] {
+        &self.values
     }
 
     /// Create a new [CustomConst] for an array of values of type `typ`.
@@ -85,7 +89,8 @@ impl StaticArrayValue {
             .into());
         }
         Ok(Self {
-            value: ArrayValue::new(typ, contents),
+            typ,
+            values: contents.into_iter().collect(),
             name: name.to_string(),
         })
     }
@@ -102,9 +107,12 @@ impl StaticArrayValue {
 }
 
 impl TryHash for StaticArrayValue {
-    fn try_hash(&self, st: &mut dyn hash::Hasher) -> bool {
-        st.write(self.name.as_bytes());
-        self.value.try_hash(st)
+    fn try_hash(&self, mut st: &mut dyn hash::Hasher) -> bool {
+        maybe_hash_values(&self.values, &mut st) && {
+            self.name.hash(&mut st);
+            self.typ.hash(&mut st);
+            true
+        }
     }
 }
 
@@ -123,17 +131,18 @@ impl CustomConst for StaticArrayValue {
     }
 
     fn extension_reqs(&self) -> ExtensionSet {
-        ExtensionSet::union_over(self.value.get_contents().iter().map(Value::extension_reqs))
+        ExtensionSet::union_over(self.values.iter().map(Value::extension_reqs))
             .union(EXTENSION_ID.into())
     }
 
-    delegate! {
-        to self.value {
-            fn update_extensions(
-                &mut self,
-                extensions: &WeakExtensionRegistry,
-            ) -> Result<(), ExtensionResolutionError>;
+    fn update_extensions(
+        &mut self,
+        extensions: &WeakExtensionRegistry,
+    ) -> Result<(), ExtensionResolutionError> {
+        for val in &mut self.values {
+            resolve_value_extensions(val, extensions)?;
         }
+        resolve_type_extensions(&mut self.typ, extensions)
     }
 }
 

hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@pre-mem2reg@llvm14_2.snap

@@ -163,6 +163,7 @@ impl SimpleHugrConfig {
                         logic::EXTENSION_ID,
                         collections::array::EXTENSION_ID,
                         collections::list::EXTENSION_ID,
+                        collections::static_array::EXTENSION_ID,
                     ]),
                 ),
             )

hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@pre-mem2reg@llvm14_3.snap

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