Enable commented tests for references and enums in match expressions (#5755)

## Description

This PR enables temporarily commented tests:
- related to references that were commented out because of the bug
described in #5692.
- related to enums in `match` expressions that were commented out
because of type inference issues that were fixed in #5643.

## Checklist

- [x] I have linked to any relevant issues.
- [ ] 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).
- [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: ironcev

test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_enums/src/main.sw

@@ -1,11 +1,10 @@
 script;
 
-// TODO: Add this test once numeric type inference in tuples is improved.
-// enum E {
-//     F: u64,
-//     G: (u64, u64),
-//     H: (u64, u64, u64),
-// }
+enum E {
+    F: u64,
+    G: (u64, u64),
+    H: (u64, u64, u64),
+}
 
 struct S {
     x: u64,
@@ -16,8 +15,7 @@ struct S {
 enum X {
     Y: u64,
     Z: bool,
-    // TODO: Add this test once numeric type inference in tuples is improved.
-    // K: E,
+    K: E,
     S: S,
 }
 
@@ -26,8 +24,7 @@ fn match_me(me: X) -> u64 {
         X::Y(10) | X::Y(20) | X::Y(30) => { 102030 },
         X::Y(hi) => { hi },
         X::Z(false) => { 1000 },
-        // TODO: Add this test once numeric type inference in tuples is improved.
-        // X::K(E::F(a) | E::G((101, x)) | E::H((202, 303, x))) => x,
+        X::K(E::F(x) | E::G((101, x)) | E::H((202, 303, x))) => x,
         X::S(S {x: a, y: 102, z: 103}) | X::S(S {x: 201, y: a, z: 203}) | X::S(S {x: 301, y: 302, z: a}) => a,
         X::S(_) => 8888,
         _ => { 9999 },
@@ -50,26 +47,25 @@ fn main() -> u64 {
     let x = match_me(X::Z(false));
     assert (x == 1000);
 
-    // TODO: Add this test once numeric type inference in tuples is improved.
-//    let x = match_me(X::K(E::F(42)));
-//
-//    assert (x == 42);
-//
-//    let x = match_me(X::K(E::G((101, 42))));
-//
-//    assert (x == 42);
-//
-//    let x = match_me(X::K(E::H((202, 303, 42))));
-//
-//    assert (x == 42);
-//
-//    let x = match_me(X::K(E::G((202, 42))));
-//
-//    assert (x == 9999);
-//
-//    let x = match_me(X::K(E::H((303, 303, 42))));
-//
-//    assert (x == 9999);
+    let x = match_me(X::K(E::F(42)));
+
+    assert (x == 42);
+
+    let x = match_me(X::K(E::G((101, 42))));
+
+    assert (x == 42);
+
+    let x = match_me(X::K(E::H((202, 303, 42))));
+
+    assert (x == 42);
+
+    let x = match_me(X::K(E::G((202, 42))));
+
+    assert (x == 9999);
+
+    let x = match_me(X::K(E::H((303, 303, 42))));
+
+    assert (x == 9999);
 
     let x = match_me(X::S(S { x:42, y: 102, z:103 }));
     assert (x == 42);

test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/src/lib_enum.sw

@@ -21,13 +21,12 @@ fn match_option(o: Option<Enum>) -> u64 {
             | Enum::B((111, 111, 111))
             | Enum::B((222, 222, 222))
         ) => 111111222222,
-        // TODO: Add this case once the issue with type inference in tuples is solved.
-        //Some(
-        //    Enum::A((x, 11, 11))
-        //    | Enum::A((22, x, 22))
-        //    | Enum::B((111, 111, x))
-        //    | Enum::B((x, 222, 222))
-        //) => x,
+        Some(
+           Enum::A((x, 11, 11))
+           | Enum::A((22, x, 22))
+           | Enum::B((111, 111, x))
+           | Enum::B((x, 222, 222))
+        ) => x,
         None => 5555,
         _ => 9999,
     }
@@ -64,18 +63,17 @@ pub fn test() -> u64 {
     let x = match_option(Some(Enum::B((222, 222, 222))));
     assert(x == 111111222222);
 
-    // TODO: Add this case once the issue with type inference in tuples is solved.
-    //let x = match_option(Some(Enum::A((42, 11, 11))));
-    //assert(x == 42);
+    let x = match_option(Some(Enum::A((42, 11, 11))));
+    assert(x == 42);
 
-    //let x = match_option(Some(Enum::A((22, 42, 22))));
-    //assert(x == 42);
+    let x = match_option(Some(Enum::A((22, 42, 22))));
+    assert(x == 42);
 
-    //let x = match_option(Some(Enum::B((111, 111, 42))));
-    //assert(x == 42);
+    let x = match_option(Some(Enum::B((111, 111, 42))));
+    assert(x == 42);
 
-    //let x = match_option(Some(Enum::B((42, 222, 222))));
-    //assert(x == 42);
+    let x = match_option(Some(Enum::B((42, 222, 222))));
+    assert(x == 42);
 
     let x = match_option(None);
     assert(x == 5555);

test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/src/lib_tuple.sw

@@ -3,9 +3,7 @@ library;
 fn match_tuple(t: (u64, u64)) -> u64 {
     match t {
         (11, 111) | (22, 222) | (33, 333) => 112233,
-        // TODO: Add these tests once the issue with type inference is solved.
-        //       Mismatched types.  expected: (u64, u64) found: (numeric, {unknown}).
-        // (11, x) | (22, x) | (33, x) => x,
+        (11, x) | (22, x) | (33, x) => x,
         _ => {
             return 9999;
         },
@@ -22,6 +20,15 @@ pub fn test() -> u64 {
     let x = match_tuple((33, 333));
     assert(x == 112233);
 
+    let x = match_tuple((11, 42));
+    assert(x == 42);
+
+    let x = match_tuple((22, 42));
+    assert(x == 42);
+
+    let x = match_tuple((33, 42));
+    assert(x == 42);
+
     let x = match_tuple((0, 0));
     assert(x == 9999);
 

test/src/e2e_vm_tests/test_programs/should_pass/language/references/referencing_local_vars_and_values/src/main.sw

@@ -124,21 +124,19 @@ fn reference_zero_sized_local_var_and_value<T>()
 {
     assert(__size_of::<T>() == 0);
 
-    // TODO-IG: Return test for mutable references once https://github.com/FuelLabs/sway/issues/5692 is fixed.
-    // let mut x = T::new();
-    let x = T::new();
+    let mut x = T::new();
 
     let r_x_1 = &x;
     let r_x_2 = &x;
     let r_val = &T::new();
 
     assert_references_zero_size(r_x_1, r_x_2, r_val, x);
 
-    // let r_x_1 = &mut x;
-    // let r_x_2 = &mut x;
-    // let r_val = &mut T::new();
+    let r_x_1 = &mut x;
+    let r_x_2 = &mut x;
+    let r_val = &mut T::new();
 
-    // assert_references_zero_size(r_x_1, r_x_2, r_val, x);
+    assert_references_zero_size(r_x_1, r_x_2, r_val, x);
 }
 
 fn assert_references_zero_size<T>(r_x_1: &T, r_x_2: &T, r_val: &T, x: T) where T: Eq + New + ZeroSize {