chore: bump forc to 0.68.0 (#1654)

Author: hal3e

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ env:
   FUEL_CORE_PATCH_BRANCH: ""
   FUEL_CORE_PATCH_REVISION: ""
   RUST_VERSION: 1.85.0
-  FORC_VERSION: 0.67.0
+  FORC_VERSION: 0.68.0
   FORC_PATCH_BRANCH: ""
   FORC_PATCH_REVISION: ""
   NEXTEST_HIDE_PROGRESS_BAR: "true"

e2e/sway/types/contracts/vectors/src/eq_impls.sw

@@ -2,13 +2,6 @@ library;
 
 use ::data_structures::{SomeEnum, SomeStruct};
 
-impl PartialEq for (u32, u32) {
-    fn eq(self, other: Self) -> bool {
-        self.0 == other.0 && self.1 == other.1
-    }
-}
-impl Eq for (u32, u32) {}
-
 impl PartialEq for SomeEnum<u32> {
     fn eq(self, other: Self) -> bool {
         match self {
@@ -22,55 +15,12 @@ impl PartialEq for SomeEnum<u32> {
         }
     }
 }
-impl Eq for SomeEnum<u32> {}
-
-impl PartialEq for Vec<u32> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<u32> {}
-
-impl PartialEq for (Vec<u32>, Vec<u32>) {
-    fn eq(self, other: Self) -> bool {
-        self.0 == other.0 && self.1 == other.1
-    }
-}
-impl Eq for (Vec<u32>, Vec<u32>) {}
-
-impl PartialEq for Vec<Vec<u32>> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<Vec<u32>> {}
 
 impl PartialEq for SomeStruct<u32> {
     fn eq(self, other: Self) -> bool {
         self.a == other.a
     }
 }
-impl Eq for SomeStruct<u32> {}
 
 impl PartialEq for [Vec<u32>; 2] {
     fn eq(self, other: Self) -> bool {
@@ -84,24 +34,6 @@ impl PartialEq for [Vec<u32>; 2] {
         true
     }
 }
-impl Eq for [Vec<u32>; 2] {}
-
-impl PartialEq for Vec<SomeStruct<u32>> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<SomeStruct<u32>> {}
 
 impl PartialEq for [u64; 2] {
     fn eq(self, other: Self) -> bool {
@@ -115,24 +47,6 @@ impl PartialEq for [u64; 2] {
         true
     }
 }
-impl Eq for [u64; 2] {}
-
-impl PartialEq for Vec<[u64; 2]> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<[u64; 2]> {}
 
 impl PartialEq for SomeEnum<Vec<u32>> {
     fn eq(self, other: Self) -> bool {
@@ -147,65 +61,15 @@ impl PartialEq for SomeEnum<Vec<u32>> {
         }
     }
 }
-impl Eq for SomeEnum<Vec<u32>> {}
-
-impl PartialEq for Vec<SomeEnum<u32>> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<SomeEnum<u32>> {}
 
-impl PartialEq for Vec<(u32, u32)> {
+impl PartialEq for SomeStruct<Vec<u32>> {
     fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
+        self.a == other.a
     }
 }
-impl Eq for Vec<(u32, u32)> {}
 
 impl PartialEq for SomeStruct<Vec<Vec<u32>>> {
     fn eq(self, other: Self) -> bool {
         self.a == other.a
     }
 }
-impl Eq for SomeStruct<Vec<Vec<u32>>> {}
-
-impl PartialEq for Vec<SomeStruct<Vec<Vec<u32>>>> {
-    fn eq(self, other: Self) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-
-        let mut i = 0;
-        while i < self.len() {
-            if self.get(i).unwrap() != other.get(i).unwrap() {
-                return false;
-            }
-            i += 1;
-        }
-        true
-    }
-}
-impl Eq for Vec<SomeStruct<Vec<Vec<u32>>>> {}

e2e/sway/types/contracts/vectors/src/main.sw

@@ -18,9 +18,7 @@ abi MyContract {
     fn vec_in_enum(arg: SomeEnum<Vec<u32>>);
     fn tuple_in_vec(arg: Vec<(u32, u32)>);
     fn vec_in_tuple(arg: (Vec<u32>, Vec<u32>));
-
     fn vec_in_vec(arg: Vec<Vec<u32>>);
-
     fn vec_in_a_vec_in_a_struct_in_a_vec(arg: Vec<SomeStruct<Vec<Vec<u32>>>>);
 }
 
@@ -36,64 +34,67 @@ impl MyContract for Contract {
         expected.push(vec_from([0, 1, 2]));
         expected.push(vec_from([0, 1, 2]));
 
-        assert(expected == arg);
+        assert_eq(arg, expected);
     }
 
     fn struct_in_vec(arg: Vec<SomeStruct<u32>>) {
         let mut expected = Vec::new();
         expected.push(SomeStruct { a: 0u32 });
         expected.push(SomeStruct { a: 1u32 });
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
+
     fn vec_in_struct(arg: SomeStruct<Vec<u32>>) {
         let expected = SomeStruct {
             a: vec_from([0, 1, 2]),
         };
 
-        assert(arg.a == expected.a);
+        assert_eq(arg, expected);
     }
+
     fn array_in_vec(arg: Vec<[u64; 2]>) {
         let mut expected = Vec::new();
         expected.push([0, 1]);
         expected.push([0, 1]);
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
 
     fn vec_in_array(arg: [Vec<u32>; 2]) {
         let expected = [vec_from([0, 1, 2]), vec_from([0, 1, 2])];
 
-        assert(expected == arg);
+        assert_eq(arg, expected);
     }
 
     fn vec_in_enum(arg: SomeEnum<Vec<u32>>) {
         let vec = vec_from([0, 1, 2]);
         let expected = SomeEnum::a(vec);
 
-        assert(expected == arg);
+        assert_eq(arg, expected);
     }
     fn enum_in_vec(arg: Vec<SomeEnum<u32>>) {
         let mut expected = Vec::new();
         expected.push(SomeEnum::a(0u32));
         expected.push(SomeEnum::a(1u32));
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
 
     fn tuple_in_vec(arg: Vec<(u32, u32)>) {
         let mut expected = Vec::new();
         expected.push((0u32, 0u32));
         expected.push((1u32, 1u32));
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
 
     fn vec_in_tuple(arg: (Vec<u32>, Vec<u32>)) {
         let expected = (vec_from([0, 1, 2]), vec_from([0, 1, 2]));
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
+
     fn vec_in_a_vec_in_a_struct_in_a_vec(arg: Vec<SomeStruct<Vec<Vec<u32>>>>) {
         let mut expected = Vec::new();
 
@@ -117,6 +118,6 @@ impl MyContract for Contract {
 
         expected.push(SomeStruct { a: inner_vec_2 });
 
-        assert(arg == expected);
+        assert_eq(arg, expected);
     }
 }