iterator trait for arrays

Author: xunilrj

sway-core/src/type_system/id.rs

@@ -8,9 +8,9 @@ use sway_error::{
 use sway_types::{BaseIdent, Named, Span, Spanned};
 
 use crate::{
-    decl_engine::{DeclEngineGet, DeclEngineInsert, MaterializeConstGenerics},
+    decl_engine::{DeclEngineGet, DeclEngineGetParsedDecl, DeclEngineInsert, MaterializeConstGenerics},
     engine_threading::{DebugWithEngines, DisplayWithEngines, Engines, WithEngines},
-    language::CallPath,
+    language::{ty::TyStructDecl, CallPath},
     namespace::TraitMap,
     semantic_analysis::TypeCheckContext,
     type_system::priv_prelude::*,
@@ -150,10 +150,28 @@ impl MaterializeConstGenerics for TypeId {
                 let mut decl = (*decl).clone();
                 decl.materialize_const_generics(engines, handler, name, value)?;
 
-                let decl_ref = engines.de().insert(decl, None);
+                let parsed_decl = engines.de()
+                    .get_parsed_decl(id)
+                    .unwrap()
+                    .to_enum_decl(handler, engines)
+                    .ok();
+                let decl_ref = engines.de().insert(decl, parsed_decl.as_ref());
 
                 *self = engines.te().insert_enum(engines, *decl_ref.id());
             }
+            TypeInfo::Struct(id) => {
+                let mut decl = TyStructDecl::clone(&engines.de().get(id));
+                decl.materialize_const_generics(engines, handler, name, value)?;
+
+                let parsed_decl = engines.de()
+                    .get_parsed_decl(id)
+                    .unwrap()
+                    .to_struct_decl(handler, engines)
+                    .ok();
+                let decl_ref = engines.de().insert(decl, parsed_decl.as_ref());
+
+                *self = engines.te().insert_struct(engines, *decl_ref.id());
+            }
             TypeInfo::StringArray(Length(ConstGenericExpr::AmbiguousVariableExpression {
                 ident,
             })) if ident.as_str() == name => {

sway-lib-std/src/iterator.sw

@@ -58,3 +58,66 @@ pub trait Iterator {
     /// ```
     fn next(ref mut self) -> Option<Self::Item>;
 }
+
+// Array Iterator
+
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> [T; N] {
+    fn iter(self) -> ArrayIterator<T, N> {
+        ArrayIterator { array: self, idx: 0 }
+    }
+}
+
+#[cfg(experimental_const_generics = true)]
+pub struct ArrayIterator<T, const N: u64> {
+    array: [T; N],
+    idx: u64,
+}
+
+#[cfg(experimental_const_generics = true)]
+impl<T, const N: u64> Iterator for ArrayIterator<T, N> {
+    type Item = T;
+
+    fn next(ref mut self) -> Option<Self::Item> {
+        if self.idx >= N {
+            None
+        } else {
+            let elem = __elem_at(&self.array, self.idx);
+            self.idx += 1;
+            Some(*elem)
+        }
+    }
+}
+
+// Tests
+
+#[cfg(experimental_const_generics = true)]
+#[test]
+fn ok_array_iterator_manual() {
+    use ::assert::*;
+    let array: [u64; 3] = [1u64, 2u64, 3u64];
+
+    let mut iterator = array.iter();
+    let a = iterator.next();
+    let b = iterator.next();
+    let c = iterator.next();
+    let d = iterator.next();
+
+    assert(a == Some(1u64));
+    assert(b == Some(2u64));
+    assert(c == Some(3u64));
+    assert(d == None);
+}
+
+#[cfg(experimental_const_generics = true)]
+#[test]
+fn ok_array_iterator_for() {
+    use ::assert::*;
+    let array: [u64; 3] = [1u64, 2u64, 3u64];
+
+    let mut value = 0;
+    for v in array.iter() {
+        value += v;
+    }
+    assert(value == 6);
+}