Add move semantics edge-case tests

tests/move/test_move_01.zc

@@ -0,0 +1,14 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  consume(m)
+  consume(m) // Use-after-move
+}
+

tests/move/test_move_02.zc

@@ -0,0 +1,10 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn main() {
+  let m = M { val: 1 }
+  let a = m
+  let b = m // Use-after-move
+  println "{a.val} {b.val}"
+}

tests/move/test_move_03.zc

@@ -0,0 +1,16 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  if 1 == 1 {
+    consume(m)
+  } else {
+    consume(m)
+  }
+}

tests/move/test_move_04.zc

@@ -0,0 +1,16 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  if false {
+    consume(m)
+  }
+  consume(m)
+}
+

tests/move/test_move_05.zc

@@ -0,0 +1,16 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  while false {
+    consume(m)
+  }
+  consume(m)
+}
+

tests/move/test_move_06.zc

@@ -0,0 +1,16 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn takes_and_true(m: M) -> bool {
+  return true
+}
+
+fn main() {
+  let m = M { val: 10 }
+  if false && takes_and_true(m) {
+    println "never"
+  }
+  takes_and_true(m)
+}
+

tests/move/test_move_07.zc

@@ -0,0 +1,16 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  match 1 {
+    0 => { consume(m) }
+    _ => { consume(m) }
+  }
+}
+

tests/move/test_move_08.zc

@@ -0,0 +1,15 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+impl Copy for M {}
+
+fn consume(m: M) {
+  println "{m.val}"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  consume(m)
+  consume(m)
+}

tests/move/test_move_09.zc

@@ -0,0 +1,13 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn borrow(m: M*) {
+  println "borrowed"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  borrow(&m)
+  borrow(&m)
+}

tests/move/test_move_10.zc

@@ -0,0 +1,15 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  consume(m)
+  let x = m.val
+  println "{x}"
+}
+

tests/move/test_move_11.zc

@@ -0,0 +1,18 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn borrow(m: M*) {
+  println "borrow"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  consume(m)
+  borrow(&m)
+}
+

tests/move/test_move_12.zc

@@ -0,0 +1,14 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main() {
+  let m = M { val: 10 }
+  consume(m)
+  println "{m.val}"
+}
+

tests/move/test_move_13.zc

@@ -0,0 +1,19 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main(argc: int, argv: char**) {
+  let m = M { val: 10 }
+  consume(m)
+
+  if argc == 1 {
+    m = M { val: 20 }
+  }
+
+  consume(m)
+}
+

tests/move/test_move_14.zc

@@ -0,0 +1,17 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main(argc: int, argv: char**) {
+  let m = M { val: 10 }
+
+  if argc == 1 {
+    consume(m)
+  } else {
+    consume(m)
+  }
+}

tests/move/test_move_15.zc

@@ -0,0 +1,17 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main() {
+  let m = M { val: 10 }
+
+  match 1 {
+    0 => { consume(m) }
+    _ => { consume(m) }
+  }
+}
+

tests/move/test_move_16.zc

@@ -0,0 +1,17 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume_and_true(m: M) -> bool {
+  println "consume"
+  return true
+}
+
+fn main() {
+  let m = M { val: 10 }
+  if false && consume_and_true(m) {
+    println "never"
+  }
+  consume_and_true(m)
+}
+

tests/move/test_move_17.zc

@@ -0,0 +1,18 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main() {
+  let m = M { val: 10 }
+
+  while false {
+    consume(m)
+  }
+
+  consume(m)
+}
+

tests/move/test_move_18.zc

@@ -0,0 +1,18 @@
+// EXPECT: PASS
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+fn main() {
+  let m = M { val: 10 }
+
+  if false {
+    consume(m)
+  }
+
+  consume(m)
+}
+

tests/move/test_move_19.zc

@@ -0,0 +1,17 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume"
+}
+
+test "move in test block" {
+  let m = M { val: 10 }
+  consume(m)
+  let x = m.val
+  assert(x == 10, "must fail")
+}
+
+fn main() {}
+

tests/move/test_move_20.zc

@@ -0,0 +1,15 @@
+// EXPECT: FAIL
+
+struct M { val: int }
+
+fn bad() -> M {
+  let m = M { val: 10 }
+  let n = m
+  return m
+}
+
+fn main() {
+  let x = bad()
+  println "{x.val}"
+}
+

tests/move/test_move_21.zc

@@ -0,0 +1,22 @@
+// EXPECT: PASS
+
+// Complex control-flow: exactly one consume per path, should be valid.
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume {m.val}"
+}
+
+fn main(argc: int, argv: char**) {
+  let m = M { val: 10 }
+
+  if argc == 1 {
+    if argc == 2 {
+      consume(m)
+    } else {
+      consume(m)
+    }
+  } else {
+    consume(m)
+  }
+}

tests/move/test_move_22.zc

@@ -0,0 +1,22 @@
+// EXPECT: PASS
+
+// if + match nesting, still one move on every concrete path.
+struct M { val: int }
+
+fn consume(m: M) {
+  println "consume {m.val}"
+}
+
+fn main(argc: int, argv: char**) {
+  let m = M { val: 20 }
+
+  if argc > 0 {
+    match argc {
+      1 => { consume(m) }
+      _ => { consume(m) }
+    }
+  } else {
+    consume(m)
+  }
+}
+