impl PartialEq, Eq, Hash, Clone for array (#7037)

## Description

This PR is part of #6860.

It continues the implementation of more `std` library "traits" for
arrays.
It also fixes a small error when formatting "const generics
declarations".

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: xunilrj

sway-core/src/language/ty/expression/expression.rs

@@ -383,6 +383,12 @@ impl MaterializeConstGenerics for TyExpression {
         self.return_type
             .materialize_const_generics(engines, handler, name, value)?;
         match &mut self.expression {
+            TyExpressionVariant::CodeBlock(block) => {
+                for node in block.contents.iter_mut() {
+                    node.materialize_const_generics(engines, handler, name, value)?;
+                }
+                Ok(())
+            }
             TyExpressionVariant::ConstGenericExpression { decl, .. } => {
                 decl.materialize_const_generics(engines, handler, name, value)
             }
@@ -393,7 +399,29 @@ impl MaterializeConstGenerics for TyExpression {
                 for (_, expr) in arguments {
                     expr.materialize_const_generics(engines, handler, name, value)?;
                 }
-
+                Ok(())
+            }
+            TyExpressionVariant::IntrinsicFunction(TyIntrinsicFunctionKind {
+                arguments, ..
+            }) => {
+                for expr in arguments {
+                    expr.materialize_const_generics(engines, handler, name, value)?;
+                }
+                Ok(())
+            }
+            TyExpressionVariant::Return(expr) => {
+                expr.materialize_const_generics(engines, handler, name, value)
+            }
+            TyExpressionVariant::IfExp {
+                condition,
+                then,
+                r#else,
+            } => {
+                condition.materialize_const_generics(engines, handler, name, value)?;
+                then.materialize_const_generics(engines, handler, name, value)?;
+                if let Some(e) = r#else.as_mut() {
+                    e.materialize_const_generics(engines, handler, name, value)?;
+                }
                 Ok(())
             }
             TyExpressionVariant::WhileLoop { condition, body } => {
@@ -407,12 +435,6 @@ impl MaterializeConstGenerics for TyExpression {
                 prefix.materialize_const_generics(engines, handler, name, value)?;
                 index.materialize_const_generics(engines, handler, name, value)
             }
-            TyExpressionVariant::IntrinsicFunction(kind) => {
-                for expr in kind.arguments.iter_mut() {
-                    expr.materialize_const_generics(engines, handler, name, value)?;
-                }
-                Ok(())
-            }
             TyExpressionVariant::Literal(_) | TyExpressionVariant::VariableExpression { .. } => {
                 Ok(())
             }
@@ -428,6 +450,9 @@ impl MaterializeConstGenerics for TyExpression {
             TyExpressionVariant::Ref(r) => {
                 r.materialize_const_generics(engines, handler, name, value)
             }
+            TyExpressionVariant::Deref(r) => {
+                r.materialize_const_generics(engines, handler, name, value)
+            }
             _ => Err(handler.emit_err(
                 sway_error::error::CompileError::ConstGenericNotSupportedHere {
                     span: self.span.clone(),

sway-lib-std/src/clone.sw

@@ -6,3 +6,67 @@ pub trait Clone {
     /// Clone self into a new value of the same type.
     fn clone(self) -> Self;
 }
+
+impl Clone for u8 {
+    fn clone(self) -> Self {
+        self
+    }
+}
+
+impl Clone for u16 {
+    fn clone(self) -> Self {
+        self
+    }
+}
+
+impl Clone for u32 {
+    fn clone(self) -> Self {
+        self
+    }
+}
+
+impl Clone for u64 {
+    fn clone(self) -> Self {
+        self
+    }
+}
+
+impl Clone for u256 {
+    fn clone(self) -> Self {
+        self
+    }
+}
+
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> Clone for [T; N]
+where
+    T: Clone,
+{
+    fn clone(self) -> Self {
+        let first: T = *__elem_at(&self, 0);
+        let mut new_array = [first.clone(); N];
+
+        let mut i = 1;
+        while __lt(i, N) {
+            let item: T = *__elem_at(&self, i);
+            let new_item: &mut T = __elem_at(&mut new_array, i);
+            *new_item = item.clone();
+            i = __add(i, 1);
+        }
+
+        new_array
+    }
+}
+
+#[cfg(experimental_const_generics = true)]
+#[test]
+fn ok_array_clone() {
+    use ::ops::*;
+
+    let a = [1, 2, 3];
+    let b = a.clone();
+
+    if !a.eq(b) {
+        __revert(5);
+    }
+}

sway-lib-std/src/codec.sw

@@ -698,7 +698,7 @@ impl AbiEncode for raw_slice {
 }
 
 #[cfg(experimental_const_generics = true)]
-impl<T, const N:u64> AbiEncode for [T; N]
+impl<T, const N: u64> AbiEncode for [T; N]
 where
     T: AbiEncode,
 {
@@ -3219,7 +3219,7 @@ impl AbiDecode for str[64] {
 // END STRARRAY_DECODE
 
 #[cfg(experimental_const_generics = true)]
-impl<T, const N:u64> AbiDecode for [T; N]
+impl<T, const N: u64> AbiDecode for [T; N]
 where
     T: AbiDecode,
 {

sway-lib-std/src/hash.sw

@@ -241,6 +241,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 1]
 where
     T: Hash,
@@ -250,6 +251,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 2]
 where
     T: Hash,
@@ -260,6 +262,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 3]
 where
     T: Hash,
@@ -271,6 +274,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 4]
 where
     T: Hash,
@@ -283,6 +287,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 5]
 where
     T: Hash,
@@ -296,6 +301,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 6]
 where
     T: Hash,
@@ -310,6 +316,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 7]
 where
     T: Hash,
@@ -325,6 +332,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 8]
 where
     T: Hash,
@@ -341,6 +349,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 9]
 where
     T: Hash,
@@ -358,6 +367,7 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = false)]
 impl<T> Hash for [T; 10]
 where
     T: Hash,
@@ -376,6 +386,21 @@ where
     }
 }
 
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> Hash for [T; N]
+where
+    T: Hash,
+{
+    fn hash(self, ref mut state: Hasher) {
+        let mut i = 0;
+        while __lt(i, N) {
+            let item: T = *__elem_at(&self, i);
+            item.hash(state);
+            i = __add(i, 1);
+        }
+    }
+}
+
 /// Returns the `SHA-2-256` hash of `param`.
 ///
 /// # Arguments
@@ -462,3 +487,16 @@ where
     s.hash(hasher);
     hasher.keccak256()
 }
+
+#[cfg(experimental_const_generics = true)]
+#[test]
+fn ok_array_hash() {
+    use ::ops::*;
+
+    let a = sha256([1, 2, 3]);
+    let b = sha256((1, 2, 3));
+
+    if a != b {
+        __revert(0);
+    }
+}

sway-lib-std/src/ops.sw

@@ -729,6 +729,34 @@ impl PartialEq for raw_ptr {
 
 impl Eq for raw_ptr {}
 
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> PartialEq for [T; N]
+where
+    T: PartialEq,
+{
+    fn eq(self, other: Self) -> bool {
+        let mut i = 0;
+        while __lt(i, N) {
+            let a: T = *__elem_at(&self, i);
+            let b: T = *__elem_at(&other, i);
+
+            if !a.eq(b) {
+                return false;
+            }
+
+            i = __add(i, 1);
+        };
+
+        true
+    }
+}
+
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> Eq for [T; N]
+where
+    T: Eq,
+{}
+
 /// Trait to evaluate if one value is greater or less than another of the same type.
 pub trait Ord {
     /// Evaluates if one value of the same type is greater than another.
@@ -1611,3 +1639,29 @@ fn u64_as_u8(val: u64) -> u8 {
         input: u8
     }
 }
+
+#[cfg(experimental_const_generics = true)]
+#[test]
+fn ok_array_eq() {
+    let a = [1, 2, 3];
+    let b = [1, 2, 3];
+    let c = [1, 1, 1];
+
+    if !a.eq(a) {
+        __revert(0);
+    }
+
+    if !a.eq(b) {
+        __revert(0);
+    }
+    if !b.eq(a) {
+        __revert(0);
+    }
+
+    if a.eq(c) {
+        __revert(0);
+    }
+    if c.eq(a) {
+        __revert(0);
+    }
+}

swayfmt/src/utils/language/generics.rs

@@ -21,6 +21,7 @@ impl Format for GenericParam {
                 write!(formatted_code, "{} ", ConstToken::AS_STR)?;
                 let _ = ident.format(formatted_code, formatter);
                 let _ = colon(formatted_code);
+                write!(formatted_code, " ")?;
                 ty.format(formatted_code, formatter)
             }
         }

swayfmt/tests/mod.rs

@@ -1267,7 +1267,7 @@ fn impl_spacing() {
             fn is_baz_true(self) -> bool;
         }
 
-        impl<A ,     B>    Qux<A, B> for
+        impl<A ,     B ,  const  N   :     u64>    Qux<A, B> for
         Foo
         where
             A    : Qux,
@@ -1287,7 +1287,7 @@ fn impl_spacing() {
             fn is_baz_true(self) -> bool;
         }
 
-        impl<A, B> Qux<A, B> for Foo
+        impl<A, B, const N: u64> Qux<A, B> for Foo
         where
             A: Qux,
             B: Qux,