Fix missing drops when ignoring match values

When the first case in a match expression returns a `Nil`, the values
returned by other cases (regardless of their type) are to be ignored,
and dropped at the end of the case body. This wasn't implemented
correctly, resulting in either drop errors (in case a reference was
returned), or a leak (when returning an owned value).

Changelog: fixed

compiler/src/type_check/expressions.rs

@@ -3063,8 +3063,16 @@ impl<'a> CheckMethodBody<'a> {
                 let typ =
                     self.last_expression_type(&mut case.body, &mut new_scope);
 
-                // If an arm returns a Never type we'll ignore it. This way e.g.
-                // the first arm can return `Never` and the other arms can
+                // If the first case returns `Nil`, the value returned by other
+                // cases is to be ignored. In this case we also want to discard
+                // the case body's return values, so we have to overwrite the
+                // `write_result` field.
+                if typ.is_nil(self.db()) {
+                    node.write_result = false;
+                }
+
+                // If a case returns a Never type we'll ignore it. This way e.g.
+                // the first case can return `Never` and the other cases can
                 // return other types, as long as those types are compatible
                 // with the first non-Never type.
                 if !typ.is_never(self.db()) {

std/test/compiler/test_pattern_matching.inko

@@ -66,4 +66,15 @@ fn pub tests(t: mut Tests) {
       case _ -> {}
     }
   }
+
+  # This test checks if the `mut a` reference is dropped at the end of the match
+  # arm, because the first match case returns `Nil`.
+  t.no_panic('match drops case return values when they are to be ignored') fn {
+    let a = [10]
+
+    match 10 {
+      case 5 -> nil
+      case _ -> mut a
+    }
+  }
 }