Demonstrate that T for Vec can now be inferred by arguments

test/src/e2e_vm_tests/test_programs/should_fail/vec/.gitignore

@@ -0,0 +1,2 @@
+out
+target

test/src/e2e_vm_tests/test_programs/should_fail/vec/Forc.lock

@@ -0,0 +1,14 @@
+[[package]]
+name = 'core'
+source = 'path+from-root-E8B33641BFB485A7'
+dependencies = []
+
+[[package]]
+name = 'std'
+source = 'path+from-root-E8B33641BFB485A7'
+dependencies = ['core']
+
+[[package]]
+name = 'vec'
+source = 'root'
+dependencies = ['std']

test/src/e2e_vm_tests/test_programs/should_fail/vec/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <[email protected]>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "vec"
+
+[dependencies]
+std = { path = "../../../../../../sway-lib-std" }

test/src/e2e_vm_tests/test_programs/should_fail/vec/src/main.sw

@@ -0,0 +1,113 @@
+script;
+
+use std::{assert::assert, hash::sha256, option::Option, revert::revert, vec::Vec};
+
+struct SimpleStruct {
+    x: u32,
+    y: b256,
+}
+
+enum SimpleEnum {
+    X: (),
+    Y: b256,
+    Z: (b256,
+    b256), 
+}
+
+fn main() -> bool {
+    test_vector_new_u8();
+    true
+}
+
+fn test_vector_new_u8() {
+    let mut vector = ~Vec::new();
+
+    let number0 = 0u8;
+    let number1 = 1u8;
+    let number2 = 2u8;
+    let number3 = 3u8;
+    let number4 = 4u8;
+    let number5 = 5u8;
+    let number6 = 6u8;
+    let number7 = 7u8;
+    let number8 = 8u8;
+
+    assert(vector.len() == 0);
+    assert(vector.capacity() == 0);
+    assert(vector.is_empty());
+
+    vector.push(number0);
+    vector.push(number1);
+    vector.push(number2);
+    vector.push(number3);
+    vector.push(number4);
+    vector.push(false);
+
+    assert(vector.len() == 5);
+    assert(vector.capacity() == 8);
+    assert(vector.is_empty() == false);
+
+    match vector.get(0) {
+        Option::Some(val) => assert(val == number0), Option::None => revert(0), 
+    }
+
+    // Push after get
+    vector.push(number5);
+    vector.push(number6);
+    vector.push(number7);
+    vector.push(number8);
+    vector.push("this should break it 1");
+
+    match vector.get(4) {
+        Option::Some(val) => assert(val == number4), Option::None => revert(0), 
+    }
+
+    match vector.get(number6) {
+        Option::Some(val) => assert(val == number6), Option::None => revert(0), 
+    }
+
+    assert(vector.len() == 9);
+    assert(vector.capacity() == 16);
+    assert(!vector.is_empty());
+
+    // Test after capacity change
+    match vector.get(4) {
+        Option::Some(val) => assert(val == number4), Option::None => revert(0), 
+    }
+
+    match vector.get(6) {
+        Option::Some(val) => assert(val == number6), Option::None => revert(0), 
+    }
+
+    vector.clear();
+
+    // Empty after clear
+    assert(vector.len() == 0);
+    assert(vector.capacity() == 16);
+    assert(vector.is_empty() == true);
+
+    match vector.get(0) {
+        Option::Some(val) => revert(0), Option::None => (), 
+    }
+
+    // Make sure pushing again after clear() works
+    vector.push(number0);
+    vector.push(number1);
+    vector.push(number2);
+    vector.push(number3);
+    vector.push(number4);
+    vector.push("this should break it 2");
+
+    assert(vector.len() == 5);
+    assert(vector.capacity() == 16);
+    assert(vector.is_empty() == false);
+
+    match vector.get(4) {
+        Option::Some(val) => assert(val == number4), Option::None => revert(0), 
+    }
+
+    // Out of bounds access
+    match vector.get(5) {
+        Option::Some(val) => revert(0), Option::None => (), 
+    }
+}

test/src/e2e_vm_tests/test_programs/should_fail/vec/test.toml

@@ -0,0 +1,10 @@
+category = "fail"
+
+# check: vector.push(false);
+# nextln: $()This parameter was declared as type u8, but argument of type bool was provided.
+
+# check: vector.push("this should break it 1");
+# nextln: $()This parameter was declared as type u8, but argument of type str[22] was provided.
+
+# check: vector.push("this should break it 2");
+# nextln: $()This parameter was declared as type u8, but argument of type str[22] was provided.

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/src/main.sw

@@ -27,7 +27,7 @@ fn main() -> bool {
 }
 
 fn test_vector_new_u8() {
-    let mut vector: Vec<u8> = ~Vec::new::<u8>();
+    let mut vector = ~Vec::new();
 
     let number0 = 0u8;
     let number1 = 1u8;
@@ -117,7 +117,7 @@ fn test_vector_new_u8() {
 }
 
 fn test_vector_new_b256() {
-    let mut vector: Vec<b256> = ~Vec::new::<b256>();
+    let mut vector = ~Vec::new();
 
     let b0 = 0x0000000000000000000000000000000000000000000000000000000000000000;
     let b1 = 0x0000000000000000000000000000000000000000000000000000000000000001;
@@ -207,7 +207,7 @@ fn test_vector_new_b256() {
 }
 
 fn test_vector_new_struct() {
-    let mut vector: Vec<SimpleStruct> = ~Vec::new::<SimpleStruct>();
+    let mut vector = ~Vec::new();
 
     let number0 = 0u32;
     let number1 = 1u32;
@@ -359,7 +359,7 @@ fn test_vector_new_struct() {
 }
 
 fn test_vector_new_enum() {
-    let mut vector: Vec<SimpleEnum> = ~Vec::new::<SimpleEnum>();
+    let mut vector = ~Vec::new();
 
     let b0 = 0x0000000000000000000000000000000000000000000000000000000000000000;
     let b1 = 0x0000000000000000000000000000000000000000000000000000000000000001;
@@ -412,7 +412,7 @@ fn test_vector_new_enum() {
 }
 
 fn test_vector_new_tuple() {
-    let mut vector: Vec<(u16, b256)> = ~Vec::new::<(u16, b256)>();
+    let mut vector = ~Vec::new();
 
     let number0 = 0u16;
     let number1 = 1u16;
@@ -536,7 +536,7 @@ fn test_vector_new_tuple() {
 }
 
 fn test_vector_new_string() {
-    let mut vector: Vec<str[4]> = ~Vec::new::<str[4]>();
+    let mut vector = ~Vec::new();
 
     let s0 = "fuel";
     let s1 = "john";
@@ -578,9 +578,7 @@ fn test_vector_new_string() {
 }
 
 fn test_vector_new_array() {
-    let mut vector: Vec<[u64;
-    3]> = ~Vec::new::<[u64;
-    3]>();
+    let mut vector = ~Vec::new();
 
     let a0 = [0, 1, 2];
     let a1 = [3, 4, 5];
@@ -628,7 +626,7 @@ fn test_vector_new_array() {
 }
 
 fn test_vector_with_capacity_u64() {
-    let mut vector: Vec<u64> = ~Vec::with_capacity::<u64>(8);
+    let mut vector = ~Vec::with_capacity(8);
 
     let number0 = 0;
     let number1 = 1;