Check vector type usage (#29247)

* Check vector element types

Add missing type check to vector element types similar to array element types

Fixes #29227

* Disallow invalid uses of vector types

Fix larger issue where the invalidity of uses of vector types outside
storage wasn't checked and would also result in panics.

* Add test

---------

Co-authored-by: Mohammad Fawaz <mohammadfawaz89@gmail.com>

Author: IGI-111

crates/errors/src/errors/type_checker/type_checker_error.rs

@@ -1516,4 +1516,11 @@ create_messages!(
         msg: format!("Dynamic call returns record type `{record_type}`, but dynamic calls return `dyn record`."),
         help: Some("Dynamic calls cannot return concrete record types. Access fields on the returned `dyn record` with type annotations: `let x: u64 = result.field;`".to_string()),
     }
+
+    @formatted
+    vector_type_only_in_storage {
+        args: (),
+        msg: format!("Vector types can only be used in storage declarations."),
+        help: None,
+    }
 );

crates/passes/src/type_checking/visitor.rs

@@ -1745,6 +1745,11 @@ impl TypeCheckingVisitor<'_> {
                 self.assert_type_is_valid(inner, span);
             }
 
+            // Vector types can only be used in storage declarations.
+            Type::Vector(_) => {
+                self.emit_err(TypeCheckerError::vector_type_only_in_storage(span));
+            }
+
             Type::Address
             | Type::Boolean
             | Type::Composite(_)
@@ -1757,7 +1762,6 @@ impl TypeCheckingVisitor<'_> {
             | Type::Integer(_)
             | Type::Scalar
             | Type::Signature
-            | Type::Vector(_)
             | Type::Numeric
             | Type::Err => {} // Do nothing.
         }
@@ -1900,8 +1904,17 @@ impl TypeCheckingVisitor<'_> {
             | Type::Integer(_)
             | Type::Scalar
             | Type::Numeric
-            | Type::Err
-            | Type::Vector(_) => {} // valid
+            | Type::Err => {} // valid
+            Type::Vector(vector_type) => {
+                let element_ty = vector_type.element_type();
+                match element_ty {
+                    Type::Future(_) => self.emit_err(TypeCheckerError::invalid_storage_type("future", span)),
+                    Type::Tuple(_) => self.emit_err(TypeCheckerError::invalid_storage_type("tuple", span)),
+                    Type::Optional(_) => self.emit_err(TypeCheckerError::invalid_storage_type("optional", span)),
+                    _ => {}
+                }
+                self.assert_storage_type_is_valid(element_ty, span);
+            }
         }
     }
 

tests/expectations/compiler/array/array_of_records_fail.out

@@ -0,0 +1,10 @@
+Error [ETYC0372079]: An array cannot have a record as an element type
+    --> compiler-test:8:9
+     |
+   8 |         data: [token; 2],
+     |         ^^^^^^^^^^^^^^^^
+Error [ETYC0372079]: An array cannot have a record as an element type
+    --> compiler-test:13:9
+     |
+  13 |         let arr: [token; 2] = [t, t];
+     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/expectations/compiler/function/undefined_vector_element_type_fail.out

@@ -0,0 +1,5 @@
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:3:12
+     |
+   3 |     fn foo(a: [Nonexistent]) -> bool {
+     |            ^^^^^^^^^^^^^^^^

tests/expectations/compiler/function/vector_type_not_allowed_fail.out

@@ -0,0 +1,40 @@
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:14:5
+     |
+  14 |     data: [u32]
+     |     ^^^^^^^^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:26:9
+     |
+  26 |         data: [u32]
+     |         ^^^^^^^^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:30:5
+     |
+  30 |     mapping my_map: [u32] => u32;
+     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:33:5
+     |
+  33 |     mapping my_map2: u32 => [u32];
+     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:3:8
+     |
+   3 | fn foo(a: [u32]) -> u32 {
+     |        ^^^^^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:8:13
+     |
+   8 | fn bar() -> [u32] {
+     |             ^^^^^
+Error [ETYC0372117]: Expected type `[u32]` but type `u32` was found.
+    --> compiler-test:9:12
+     |
+   9 |     return 0u32;
+     |            ^^^^
+Error [ETYC0372189]: Vector types can only be used in storage declarations.
+    --> compiler-test:18:8
+     |
+  18 | fn baz(a: [[u32]; 3]) -> u32 {
+     |        ^^^^^^^^^^^^^

tests/tests/compiler/array/array_of_records_fail.leo

@@ -0,0 +1,16 @@
+program test.aleo {
+    record token {
+        owner: address,
+        amount: u64,
+    }
+
+    struct wrapper {
+        data: [token; 2],
+    }
+
+    fn main(owner: address) -> u8 {
+        let t: token = token { owner: owner, amount: 1u64 };
+        let arr: [token; 2] = [t, t];
+        return 0u8;
+    }
+}

tests/tests/compiler/function/undefined_vector_element_type_fail.leo

@@ -0,0 +1,6 @@
+
+program test.aleo {
+    fn foo(a: [Nonexistent]) -> bool {
+        return true;
+    }
+}

tests/tests/compiler/function/vector_type_not_allowed_fail.leo

@@ -0,0 +1,38 @@
+
+// Vector as function parameter
+fn foo(a: [u32]) -> u32 {
+    return 0u32;
+}
+
+// Vector as function return type
+fn bar() -> [u32] {
+    return 0u32;
+}
+
+// Vector as struct field
+struct MyStruct {
+    data: [u32]
+}
+
+// Vector nested in array
+fn baz(a: [[u32]; 3]) -> u32 {
+    return 0u32;
+}
+
+program test.aleo {
+    // Vector as record field
+    record MyRecord {
+        owner: address,
+        data: [u32]
+    }
+
+    // Vector as mapping key type
+    mapping my_map: [u32] => u32;
+
+    // Vector as mapping value type
+    mapping my_map2: u32 => [u32];
+
+    fn main() -> Final {
+        return final {};
+    }
+}